vike 0.4.220-commit-af5c91f → 0.4.221-commit-8577456

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

@@ -2,64 +2,94 @@
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
 // Internal use
-export { getGlobalContext };
+export { getGlobalContextInternal };
 export { getViteDevServer };
 export { getViteConfig };
 export { initGlobalContext_renderPage };
 export { initGlobalContext_runPrerender };
-export { initGlobalContext_getGlobalContextAsync };
+export { initGlobalContext_getPagesAndRoutes };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
-export { setGlobalContext_vikeConfig };
-export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
+export { setGlobalContext_isProduction };
 export { setGlobalContext_buildEntry };
 export { clearGlobalContext };
 export { assertBuildInfo };
 export { getViteConfigRuntime };
+export { updateUserFiles };
+// The core logic revolves around:
+// - globalObject.userFiles which is the main requirement for assembleGlobalContext()
+// - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
+//   - loadBuildEntry() sets globalObject.buildEntry and then sets globalObject.userFiles
+//   - With vike-server it's set at server start: @brillout/vite-plugin-server-entry injects `import './entry.mjs'` (the production entry generated by @brillout/vite-plugin-server-entry) as first line of code of dist/server/index.mjs while dist/server/entry.mjs calls setGlobalContext_buildEntry()
+//   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
+// - In development: globalObject.viteDevServer which is Vite's development server
+//   - globalObject.viteDevServer is used by updateUserFiles() which then sets globalConfig.userFiles
 import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy, projectInfo, checkType } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.js';
-import { getPageFilesAll, setPageFiles, setPageFilesAsync } from '../../shared/getPageFiles/getPageFiles.js';
 import pc from '@brillout/picocolors';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { assertV1Design } from '../shared/assertV1Design.js';
+import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
 const debug = createDebugger('vike:globalContext');
 const globalObject = getGlobalObject('globalContext.ts', getInitialGlobalContext());
-initDevEntry();
-function getGlobalContext() {
-    if (!globalObject.globalContext) {
-        debug('getGlobalContext()', new Error().stack);
+async function getGlobalContextInternal() {
+    // getGlobalContextInternal() should always be called after initGlobalContext()
+    assert(globalObject.isInitialized);
+    assertGlobalContextIsDefined();
+    if (globalObject.isProduction !== true)
+        await globalObject.waitForUserFilesUpdate;
+    const { globalContext } = globalObject;
+    assertIsDefined(globalContext);
+    return globalContext;
+}
+function assertIsDefined(globalContext) {
+    if (!globalContext) {
+        debug('globalContext', globalContext);
+        debug('assertIsDefined()', new Error().stack);
         assert(false);
     }
-    return globalObject.globalContext;
+}
+function assertGlobalContextIsDefined() {
+    assertIsDefined(globalObject.globalContext);
+    assert(globalObject.globalContext_public);
 }
 /** @experimental https://vike.dev/getGlobalContext */
 function getGlobalContextSync() {
-    assertUsage(globalObject.globalContext, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContextAsync() instead.");
-    return makePublic(globalObject.globalContext);
+    const { globalContext_public } = globalObject;
+    assertUsage(globalContext_public, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContextAsync() instead.");
+    return globalContext_public;
 }
 /** @experimental https://vike.dev/getGlobalContext */
 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);
+    setIsProduction(isProduction);
+    if (!globalObject.globalContext)
+        await initGlobalContext_getGlobalContextAsync();
+    if (!isProduction)
+        await globalObject.waitForUserFilesUpdate;
+    assertGlobalContextIsDefined();
+    const { globalContext_public } = globalObject;
+    assert(globalContext_public);
+    return globalContext_public;
 }
 function makePublic(globalContext) {
-    // TODO/now: add viteConfig and vikeConfig
-    const globalContextPublic = makePublicCopy(globalContext, 'globalContext', ['assetsManifest']);
+    // TODO/soon: add `pages`
+    const globalContextPublic = makePublicCopy(globalContext, 'globalContext', ['assetsManifest', 'config', 'viteConfig']);
     return globalContextPublic;
 }
-function setGlobalContext_viteDevServer(viteDevServer) {
+async function setGlobalContext_viteDevServer(viteDevServer) {
+    debug('setGlobalContext_viteDevServer()');
+    setIsProduction(false);
     if (globalObject.viteDevServer)
         return;
     assertIsNotInitilizedYet();
     assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
+    await updateUserFiles();
+    assertGlobalContextIsDefined();
     globalObject.viteDevServerPromiseResolve(viteDevServer);
-    eagerlyLoadUserFiles();
 }
 function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
     if (globalObject.viteConfig)
@@ -68,21 +98,16 @@ function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
     globalObject.viteConfig = viteConfig;
     globalObject.outDirRoot = outDirRoot;
 }
-function setGlobalContext_vikeConfig(vikeConfig) {
-    if (globalObject.vikeConfig)
-        return;
-    assertIsNotInitilizedYet();
-    globalObject.vikeConfig = vikeConfig;
-}
 function assertIsNotInitilizedYet() {
-    // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
+    // In development, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
     assert(!globalObject.globalContext);
 }
-function setGlobalContext_isViteDev(isViteDev) {
-    globalObject.isViteDev = isViteDev;
-}
 function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
+    setIsProduction(true);
+}
+function setGlobalContext_isProduction(isProduction) {
+    setIsProduction(isProduction);
 }
 function getViteDevServer() {
     return globalObject.viteDevServer ?? null;
@@ -92,10 +117,15 @@ function getViteConfig() {
 }
 async function initGlobalContext_renderPage() {
     debug('initGlobalContext_renderPage()');
-    await initGlobalContext(!globalObject.isViteDev);
+    // globalObject.isProduction isn't set upon production server without vike-server (there isn't any signal we can use)
+    if (globalObject.isProduction === undefined)
+        setIsProduction(true);
+    await initGlobalContext();
 }
 async function initGlobalContext_runPrerender() {
     debug('initGlobalContext_runPrerender()');
+    assert(globalObject.isPrerendering === true);
+    assert(globalObject.isProduction === true);
     if (globalObject.initGlobalContext_runPrerender_alreadyCalled)
         return;
     globalObject.initGlobalContext_runPrerender_alreadyCalled = true;
@@ -105,65 +135,93 @@ async function initGlobalContext_runPrerender() {
     // We assume initGlobalContext_runPrerender() to be called before:
     // - initGlobalContext_renderPage()
     // - initGlobalContext_getGlobalContextAsync()
-    assert(!globalObject.globalContext);
-    await initGlobalContext(true);
+    assertIsNotInitilizedYet();
+    await initGlobalContext();
 }
-async function initGlobalContext_getGlobalContextAsync(isProduction) {
+async function initGlobalContext_getGlobalContextAsync() {
     debug('initGlobalContext_getGlobalContextAsync()');
+    await initGlobalContext();
+}
+async function initGlobalContext_getPagesAndRoutes() {
+    debug('initGlobalContext_getPagesAndRoutes()');
+    setIsProduction(true);
+    await initGlobalContext();
+}
+async function waitForViteDevServer() {
+    debug('waitForViteDevServer()');
+    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);
+    assertGlobalContextIsDefined();
+}
+async function initGlobalContext() {
+    const { isProduction } = globalObject;
+    assert(typeof isProduction === 'boolean');
     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 waitForViteDevServer();
     }
-    await initGlobalContext(isProduction);
-}
-// TODO/now: refactor: move this to the top of the file
-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;
+    else {
+        await loadBuildEntry(globalObject.outDirRoot);
     }
-    const { viteDevServer, viteConfig, vikeConfig, isPrerendering } = globalObject;
+    assertGlobalContextIsDefined();
+    globalObject.isInitialized = true;
+}
+function setIsProduction(isProduction) {
+    debug('setIsProduction', isProduction);
+    assert(typeof isProduction === 'boolean');
+    if (globalObject.isProduction !== undefined)
+        assert(globalObject.isProduction === isProduction);
+    globalObject.isProduction = isProduction;
+}
+function defineGlobalContext() {
+    const globalContext = assembleGlobalContext();
+    assertIsDefined(globalContext);
+    const globalContext_public = makePublic(globalContext);
+    objectAssign(globalContext, { globalContext_public });
+    globalObject.globalContext = globalContext;
+    globalObject.globalContext_public = globalContext_public;
+    assertGlobalContextIsDefined();
     onSetupRuntime();
+}
+function assembleGlobalContext() {
+    const { viteDevServer, viteConfig, isPrerendering, isProduction, userFiles } = globalObject;
+    assert(typeof isProduction === 'boolean');
+    let globalContext;
     if (!isProduction) {
+        // Requires globalObject.viteDevServer
+        if (!viteDevServer)
+            return null;
+        assert(userFiles); // main common requiement
         assert(viteConfig);
-        assert(vikeConfig);
-        assert(viteDevServer);
         assert(!isPrerendering);
-        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
         const viteConfigRuntime = getViteConfigRuntime(viteConfig);
-        globalObject.globalContext = {
+        globalContext = {
             isProduction: false,
             isPrerendering: false,
             assetsManifest: null,
             viteDevServer,
             viteConfig,
-            vikeConfig: {
-                global: globalConfig
-            },
             ...userFiles,
             viteConfigRuntime
         };
     }
     else {
-        const buildEntry = await getBuildEntry(globalObject.outDirRoot, isPrerendering);
-        const { assetsManifest, buildInfo } = buildEntry;
-        setPageFiles(buildEntry.pageFiles);
-        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
-        const globalContext = {
+        // Requires globalObject.buildEntry
+        if (!globalObject.buildEntry)
+            return null;
+        assert(userFiles); // main common requiement
+        const { buildInfo, assetsManifest } = globalObject;
+        assert(buildInfo);
+        assert(assetsManifest);
+        const globalContext_ = {
             isProduction: true,
             assetsManifest,
-            vikeConfig: {
-                global: globalConfig
-            },
             ...userFiles,
             viteDevServer: null,
             viteConfigRuntime: buildInfo.viteConfigRuntime,
@@ -171,23 +229,28 @@ async function initGlobalContext(isProduction) {
         };
         if (isPrerendering) {
             assert(viteConfig);
-            objectAssign(globalContext, {
+            objectAssign(globalContext_, {
                 isPrerendering: true,
                 viteConfig
             });
-            globalObject.globalContext = globalContext;
+            globalContext = globalContext_;
         }
         else {
-            objectAssign(globalContext, {
+            objectAssign(globalContext_, {
                 isPrerendering: false,
                 viteConfig: null
             });
-            globalObject.globalContext = globalContext;
+            globalContext = globalContext_;
         }
     }
+    return globalContext;
 }
-async function getPageRuntimeInfo(isProduction) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = await getPageFilesAll(false, isProduction);
+async function getUserFiles() {
+    // Help TypeScript resolve what TypeScript (wrongfully) believes to be cyclic dependency
+    const globalObject_ = globalObject;
+    const { pageConfigsRuntime } = globalObject_;
+    assert(pageConfigsRuntime);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = pageConfigsRuntime;
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
     const userFiles = {
         pageFilesAll,
@@ -195,12 +258,13 @@ async function getPageRuntimeInfo(isProduction) {
         pageConfigGlobal,
         allPageIds,
         pageRoutes,
-        onBeforeRouteHook
+        onBeforeRouteHook,
+        config: globalConfig.config
     };
     assertV1Design(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     pageConfigs.length > 0, pageFilesAll);
-    return { userFiles, globalConfig };
+    return userFiles;
 }
 function assertViteManifest(manifest) {
     assert(isPlainObject(manifest));
@@ -215,45 +279,56 @@ 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.
-    getPageFilesExports();
-}
-async function getBuildEntry(outDir, isPrerendering) {
-    debug('getBuildEntry()');
+async function loadBuildEntry(outDir) {
+    debug('loadBuildEntry()');
+    if (globalObject.userFiles) {
+        assert(globalObject.buildInfo);
+        assert(globalObject.assetsManifest);
+        assert(globalObject.buildEntry);
+        return;
+    }
     if (!globalObject.buildEntry) {
         debug('importServerProductionEntry()');
         // importServerProductionEntry() loads dist/server/entry.mjs which calls setGlobalContext_buildEntry()
-        await importServerProductionEntry({ outDir, doNotLoadServer: isPrerendering });
+        await importServerProductionEntry({ outDir });
         if (!globalObject.buildEntry) {
             debug('globalObject.buildEntryPrevious');
             // Needed, for example, when calling the API prerender() then preview() because both trigger a importServerProductionEntry() call but only the first only is applied because of the import() cache. (A proper implementation would be to clear the import() cache, but it probably isn't possible on platforms such as Cloudflare Workers.)
             globalObject.buildEntry = globalObject.buildEntryPrevious;
         }
         assert(globalObject.buildEntry);
+        assertWarning(!globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject, 
+        // TODO/soon: show precise path
+        // TODO/soon: make this warning work on test/vike-node/
+        `Run the server production build (e.g. ${pc.cyan('$ node dist/server/index.mjs')}) instead of running the original server entry (e.g. ${pc.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
     }
     const { buildEntry } = globalObject;
     assertBuildEntry(buildEntry);
-    return buildEntry;
+    globalObject.assetsManifest = buildEntry.assetsManifest;
+    globalObject.buildInfo = buildEntry.buildInfo;
+    await setUserFiles(buildEntry.virtualFileExports);
 }
-function setGlobalContext_buildEntry(buildEntry) {
+async function setGlobalContext_buildEntry(buildEntry) {
     debug('setGlobalContext_buildEntry()');
+    setIsProduction(true);
     assertBuildEntry(buildEntry);
     globalObject.buildEntry = buildEntry;
     globalObject.buildEntryPrevious = buildEntry;
+    assert(globalObject.buildEntry); // ensure no infinite loop
+    await loadBuildEntry();
+    assertGlobalContextIsDefined();
 }
 function assertBuildEntry(buildEntry) {
     assert(isObject(buildEntry));
-    assert(hasProp(buildEntry, 'pageFiles', 'object'));
-    const { pageFiles } = buildEntry;
+    assert(hasProp(buildEntry, 'virtualFileExports', 'object'));
+    const { virtualFileExports } = buildEntry;
     assert(hasProp(buildEntry, 'assetsManifest', 'object'));
     const { assetsManifest } = buildEntry;
     assertViteManifest(assetsManifest);
     assert(hasProp(buildEntry, 'buildInfo', 'object'));
     const { buildInfo } = buildEntry;
     assertBuildInfo(buildInfo);
-    checkType({ pageFiles, assetsManifest, buildInfo });
+    checkType({ virtualFileExports, assetsManifest, buildInfo });
 }
 function assertBuildInfo(buildInfo) {
     assert(isObject(buildInfo));
@@ -261,6 +336,7 @@ function assertBuildInfo(buildInfo) {
     assertVersionAtBuildTime(buildInfo.versionAtBuildTime);
     assert(hasProp(buildInfo, 'viteConfigRuntime', 'object'));
     assert(hasProp(buildInfo.viteConfigRuntime, '_baseViteOriginal', 'string'));
+    assert(hasProp(buildInfo.viteConfigRuntime, 'vitePluginServerEntry', 'object'));
     assert(hasProp(buildInfo, 'usesClientRouter', 'boolean'));
     checkType({ ...buildInfo, viteConfigRuntime: buildInfo.viteConfigRuntime });
 }
@@ -272,28 +348,38 @@ function assertVersionAtBuildTime(versionAtBuildTime) {
 function getViteConfigRuntime(viteConfig) {
     assert(hasProp(viteConfig, '_baseViteOriginal', 'string'));
     const viteConfigRuntime = {
-        _baseViteOriginal: viteConfig._baseViteOriginal
+        _baseViteOriginal: viteConfig._baseViteOriginal,
+        vitePluginServerEntry: {
+            inject: viteConfig.vitePluginServerEntry?.inject
+        }
     };
     return viteConfigRuntime;
 }
-function initDevEntry() {
-    setPageFilesAsync(getPageFilesExports);
-}
-async function getPageFilesExports() {
+async function updateUserFiles() {
+    const { promise, resolve } = genPromise();
+    assert(!globalObject.isProduction);
+    globalObject.waitForUserFilesUpdate = promise;
     const viteDevServer = getViteDevServer();
     assert(viteDevServer);
-    let moduleExports;
+    let virtualFileExports;
     try {
-        moduleExports = await viteDevServer.ssrLoadModule(virtualFileIdImportUserCodeServer);
+        virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileIdImportUserCodeServer);
     }
     catch (err) {
         debugGlob(`Glob error: ${virtualFileIdImportUserCodeServer} transpile error: `, err);
         throw err;
     }
-    moduleExports = moduleExports.default || moduleExports;
-    debugGlob('Glob result: ', moduleExports);
-    assert(isObject(moduleExports));
-    return moduleExports;
+    virtualFileExports = virtualFileExports.default || virtualFileExports;
+    debugGlob('Glob result: ', virtualFileExports);
+    await setUserFiles(virtualFileExports);
+    resolve();
+}
+async function setUserFiles(virtualFileExports) {
+    globalObject.pageConfigsRuntime = getPageConfigsRuntime(virtualFileExports);
+    const userFiles = await getUserFiles();
+    globalObject.userFiles = userFiles;
+    defineGlobalContext();
+    assertGlobalContextIsDefined();
 }
 function clearGlobalContext() {
     debug('clearGlobalContext()');

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.d.ts

@@ -29,4 +29,4 @@ type HtmlTag = {
 };
 declare function getHtmlTags(pageContext: {
     _isStream: boolean;
-} & PageContextInjectAssets, streamFromReactStreamingPackage: null | StreamFromReactStreamingPackage, injectFilter: PreloadFilter, pageAssets: PageAsset[], viteDevScript: string, isStream: boolean): HtmlTag[];
+} & PageContextInjectAssets, streamFromReactStreamingPackage: null | StreamFromReactStreamingPackage, injectFilter: PreloadFilter, pageAssets: PageAsset[], viteDevScript: string, isStream: boolean): Promise<HtmlTag[]>;

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -7,14 +7,13 @@ import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
 import { mergeScriptTags } from './mergeScriptTags.js';
 import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
 import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValueRuntime.js';
-import { getGlobalContext } from '../../globalContext.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
 const stamp = '__injectFilterEntry';
-function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
+async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
     assert([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
-    const { isProduction } = getGlobalContext();
+    const { isProduction } = pageContext._globalContext;
     const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
     const injectFilterEntries = [];
     pageAssets

package/dist/esm/node/runtime/html/injectAssets/getViteDevScript.d.ts

@@ -1,2 +1,5 @@
 export { getViteDevScript };
-declare function getViteDevScript(): Promise<string>;
+import type { GlobalContext } from '../../globalContext.js';
+declare function getViteDevScript(pageContext: {
+    _globalContext: GlobalContext;
+}): Promise<string>;

package/dist/esm/node/runtime/html/injectAssets/getViteDevScript.js

@@ -1,9 +1,8 @@
 export { getViteDevScript };
-import { getGlobalContext } from '../../globalContext.js';
 import { assert, assertUsage, assertWarning } from '../../utils.js';
 import pc from '@brillout/picocolors';
-async function getViteDevScript() {
-    const globalContext = getGlobalContext();
+async function getViteDevScript(pageContext) {
+    const globalContext = pageContext._globalContext;
     if (globalContext.isProduction) {
         return '';
     }

package/dist/esm/node/runtime/html/injectAssets.d.ts

@@ -8,6 +8,7 @@ import { type PreloadFilter } from './injectAssets/getHtmlTags.js';
 import type { StreamFromReactStreamingPackage } from './stream/react-streaming.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageContextSerialization } from './serializePageContextClientSide.js';
+import type { GlobalContext } from '../globalContext.js';
 type PageContextInjectAssets = {
     urlPathname: string;
     __getPageAssets: () => Promise<PageAsset[]>;
@@ -21,6 +22,7 @@ type PageContextInjectAssets = {
     _baseServer: string;
     _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
+    _globalContext: GlobalContext;
 } & PageContextSerialization;
 declare function injectHtmlTagsToString(htmlParts: HtmlPart[], pageContext: PageContextInjectAssets & {
     _isStream: false;

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

@@ -7,8 +7,8 @@ import { getHtmlTags } from './injectAssets/getHtmlTags.js';
 import { getViteDevScript } from './injectAssets/getViteDevScript.js';
 async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
     const pageAssets = await pageContext.__getPageAssets();
-    const viteDevScript = await getViteDevScript();
-    const htmlTags = getHtmlTags(pageContext, null, injectFilter, pageAssets, viteDevScript, false);
+    const viteDevScript = await getViteDevScript(pageContext);
+    const htmlTags = await getHtmlTags(pageContext, null, injectFilter, pageAssets, viteDevScript, false);
     let htmlString = htmlPartsToString(htmlParts, pageAssets);
     htmlString = injectToHtmlBegin(htmlString, htmlTags);
     htmlString = injectToHtmlEnd(htmlString, htmlTags);
@@ -24,8 +24,8 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
     };
     async function injectAtStreamBegin(htmlPartsBegin) {
         const pageAssets = await pageContext.__getPageAssets();
-        const viteDevScript = await getViteDevScript();
-        htmlTags = getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, true);
+        const viteDevScript = await getViteDevScript(pageContext);
+        htmlTags = await getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, true);
         let htmlBegin = htmlPartsToString(htmlPartsBegin, pageAssets);
         htmlBegin = injectToHtmlBegin(htmlBegin, htmlTags);
         if (streamFromReactStreamingPackage) {

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

@@ -7,7 +7,6 @@ import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isH
 import { injectHtmlTagsToString, injectHtmlTagsToStream } from './injectAssets.js';
 import { processStream, isStream, streamToString } from './stream.js';
 import { isStreamFromReactStreamingPackage } from './stream/react-streaming.js';
-import { getGlobalContext } from '../globalContext.js';
 import pc from '@brillout/picocolors';
 function isDocumentHtml(something) {
     if (isTemplateWrapped(something) || isEscapedString(something) || isStream(something)) {
@@ -31,7 +30,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
     }
     if (isTemplateWrapped(documentHtml)) {
         const templateContent = documentHtml._template;
-        const render = await renderTemplate(templateContent, pageContext);
+        const render = renderTemplate(templateContent, pageContext);
         if (!('htmlStream' in render)) {
             objectAssign(pageContext, { _isStream: false });
             const { htmlPartsAll } = render;
@@ -120,7 +119,7 @@ function _dangerouslySkipEscape(arg) {
     });
     return { _escaped: String(arg) };
 }
-async function renderTemplate(templateContent, pageContext) {
+function renderTemplate(templateContent, pageContext) {
     const htmlPartsBegin = [];
     const htmlPartsEnd = [];
     let htmlStream = null;
@@ -151,7 +150,7 @@ async function renderTemplate(templateContent, pageContext) {
         // Process `escapeInject` fragments
         if (isTemplateWrapped(templateVar)) {
             const templateContentInner = templateVar._template;
-            const result = await renderTemplate(templateContentInner, pageContext);
+            const result = renderTemplate(templateContentInner, pageContext);
             if (!('htmlStream' in result)) {
                 result.htmlPartsAll.forEach(addHtmlPart);
             }
@@ -193,7 +192,7 @@ async function renderTemplate(templateContent, pageContext) {
             }
         }
         {
-            const { isProduction } = getGlobalContext();
+            const { isProduction } = pageContext._globalContext;
             if (isHtml(templateVar) &&
                 // We don't show this warning in production because it's expected that some users may (un)willingly do some XSS injection: we avoid flooding the production logs.
                 !isProduction) {

package/dist/esm/node/runtime/renderPage/analyzePage.d.ts

@@ -2,4 +2,5 @@ export { analyzePage };
 import type { PageFile } from '../../../shared/getPageFiles/getPageFileObject.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type AnalysisResult } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfigRuntime, pageId: string): AnalysisResult;
+import type { GlobalContext } from '../globalContext.js';
+declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfigRuntime, pageId: string, globalContext: GlobalContext): Promise<AnalysisResult>;

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

@@ -3,9 +3,8 @@ import { getVikeClientEntry } from '../../../shared/getPageFiles/analyzePageClie
 import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageClientSide.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
-import { getGlobalContext } from '../globalContext.js';
 import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValueRuntime.js';
-function analyzePage(pageFilesAll, pageConfig, pageId) {
+async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
     if (pageConfig) {
         const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
         const clientEntries = [];
@@ -21,7 +20,7 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
-        if (!getGlobalContext().isProduction) {
+        if (!globalContext.isProduction) {
             clientDependencies.push({
                 id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, false),
                 onlyAssets: true,

package/dist/esm/node/runtime/renderPage/getPageAssets/sortPageAssetsForEarlyHintsHeader.d.ts

@@ -1,3 +1,3 @@
 export { sortPageAssetsForEarlyHintsHeader };
 import type { PageAsset } from '../getPageAssets.js';
-declare function sortPageAssetsForEarlyHintsHeader(pageAssets: PageAsset[]): void;
+declare function sortPageAssetsForEarlyHintsHeader(pageAssets: PageAsset[], isProduction: boolean): Promise<void>;

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

@@ -1,11 +1,9 @@
 export { sortPageAssetsForEarlyHintsHeader };
-import { getGlobalContext } from '../../globalContext.js';
 import { higherFirst } from '../../utils.js';
-function sortPageAssetsForEarlyHintsHeader(pageAssets) {
-    const globalContext = getGlobalContext();
+async function sortPageAssetsForEarlyHintsHeader(pageAssets, isProduction) {
     pageAssets.sort(higherFirst(({ assetType }) => {
         // In dev, we load scripts first in order to parallelize I/O and CPU
-        if (!globalContext.isProduction && assetType === 'script') {
+        if (!isProduction && assetType === 'script') {
             return 1;
         }
         let priority = 0;