vike 0.4.228 → 0.4.229-commit-2a06dcc

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

@@ -3,7 +3,7 @@ export { getGlobalContext };
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
 // Internal use
-export { getGlobalContextInternal };
+export { getGlobalContextServerInternal };
 export { getViteDevServer };
 export { getViteConfig };
 export { initGlobalContext_renderPage };
@@ -18,32 +18,36 @@ export { clearGlobalContext };
 export { assertBuildInfo };
 export { updateUserFiles };
 // The core logic revolves around:
-// - globalObject.userFiles which is the main requirement for resolveGlobalContext()
+// - virtualFileExports is the main requirement
 // - 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
+//   - loadBuildEntry() sets globalObject.buildEntry and then sets virtualFileExports
 //   - 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, checkType, PROJECT_VERSION } from './utils.js';
+//   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExports
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, getPublicProxy, checkType, PROJECT_VERSION } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.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';
 import { resolveBase } from '../shared/resolveBase.js';
+import { createGlobalContextShared, getGlobalContextSyncErrMsg } from '../../shared/createGlobalContextShared.js';
 const debug = createDebugger('vike:globalContext');
 const globalObject = getGlobalObject('runtime/globalContext.ts', getInitialGlobalContext());
-async function getGlobalContextInternal() {
-    // getGlobalContextInternal() should always be called after initGlobalContext()
+// Trick to break down TypeScript circular dependency
+// https://chat.deepseek.com/a/chat/s/d7e9f90a-c7f3-4108-9cd5-4ad6caed3539
+const globalObjectTyped = globalObject;
+async function getGlobalContextServerInternal() {
+    // getGlobalContextServerInternal() should always be called after initGlobalContext()
     assert(globalObject.isInitialized);
     assertGlobalContextIsDefined();
     if (globalObject.isProduction !== true)
         await globalObject.waitForUserFilesUpdate;
-    const { globalContext } = globalObject;
+    const { globalContext, globalContext_public } = globalObjectTyped;
     assertIsDefined(globalContext);
-    return globalContext;
+    assert(globalContext_public);
+    return { globalContext, globalContext_public };
 }
 function assertIsDefined(globalContext) {
     if (!globalContext) {
@@ -53,9 +57,11 @@ function assertIsDefined(globalContext) {
     }
 }
 function assertGlobalContextIsDefined() {
-    assertIsDefined(globalObject.globalContext);
+    assertIsDefined(globalObjectTyped.globalContext);
+    assert(globalObject.globalContext);
     assert(globalObject.globalContext_public);
 }
+// We purposely return GlobalContext instead of GlobalContextServer because `import { getGlobalContext } from 'vike'` can resolve to the client-side implementation.
 /**
  * Get runtime information about your app.
  *
@@ -83,7 +89,7 @@ async function getGlobalContextAsync(isProduction) {
     if (!isProduction)
         await globalObject.waitForUserFilesUpdate;
     assertGlobalContextIsDefined();
-    const { globalContext_public } = globalObject;
+    const { globalContext_public } = globalObjectTyped;
     assert(globalContext_public);
     return globalContext_public;
 }
@@ -96,24 +102,25 @@ async function getGlobalContextAsync(isProduction) {
  */
 function getGlobalContextSync() {
     debug('getGlobalContextSync()');
-    const { globalContext_public } = globalObject;
-    assertUsage(globalContext_public, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.");
+    const { globalContext_public } = globalObjectTyped;
+    assertUsage(globalContext_public, getGlobalContextSyncErrMsg);
     assertWarning(false, 
-    // We discourage users from using it because using `pageContext.globalContext` is better: it doesn't have the race condition issue that `getGlobalContextSync()` would have when called inside React/Vue components.
+    // We discourage users from using it because `pageContext.globalContext` is safer: I ain't sure but there could be race conditions when using `getGlobalContextSync()` inside React/Vue components upon HMR.
     // We're lying about "is going to be deprecated in the next major release": let's keep it and see if users need it (so far I can't see a use case for it).
     'getGlobalContextSync() is going to be deprecated in the next major release, see https://vike.dev/getGlobalContext', { onlyOnce: true });
     return globalContext_public;
 }
 function makePublic(globalContext) {
-    const globalContextPublic = makePublicCopy(globalContext, 'globalContext', [
+    const globalContextPublic = getPublicProxy(globalContext, 'globalContext', [
         'assetsManifest',
         'config',
         'viteConfig',
         'viteConfigRuntime',
         'pages',
         'baseServer',
-        'baseAssets'
-    ]);
+        'baseAssets',
+        'isClientSide'
+    ], true);
     return globalContextPublic;
 }
 async function setGlobalContext_viteDevServer(viteDevServer) {
@@ -221,96 +228,6 @@ function setIsProduction(isProduction) {
         assert(globalObject.isProduction === isProduction);
     globalObject.isProduction = isProduction;
 }
-function defineGlobalContext() {
-    const globalContext = resolveGlobalContext();
-    assertIsDefined(globalContext);
-    const globalContext_public = makePublic(globalContext);
-    objectAssign(globalContext, { globalContext_public });
-    globalObject.globalContext = globalContext;
-    globalObject.globalContext_public = globalContext_public;
-    assertGlobalContextIsDefined();
-    onSetupRuntime();
-}
-function resolveGlobalContext() {
-    const { viteDevServer, viteConfig, viteConfigRuntime, 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(viteConfigRuntime);
-        assert(!isPrerendering);
-        globalContext = {
-            isProduction: false,
-            isPrerendering: false,
-            assetsManifest: null,
-            viteDevServer,
-            viteConfig,
-            ...userFiles,
-            viteConfigRuntime,
-            ...resolveBaseRuntime(viteConfigRuntime, userFiles.config)
-        };
-    }
-    else {
-        // 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,
-            ...userFiles,
-            viteDevServer: null,
-            viteConfigRuntime: buildInfo.viteConfigRuntime,
-            usesClientRouter: buildInfo.usesClientRouter,
-            ...resolveBaseRuntime(buildInfo.viteConfigRuntime, userFiles.config)
-        };
-        if (isPrerendering) {
-            assert(viteConfig);
-            objectAssign(globalContext_, {
-                isPrerendering: true,
-                viteConfig
-            });
-            globalContext = globalContext_;
-        }
-        else {
-            objectAssign(globalContext_, {
-                isPrerendering: false,
-                viteConfig: null
-            });
-            globalContext = globalContext_;
-        }
-    }
-    return globalContext;
-}
-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, pageConfigsUserFriendly } = pageConfigsRuntime;
-    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    const userFiles = {
-        pageFilesAll,
-        pageConfigs,
-        pageConfigGlobal,
-        allPageIds,
-        pageRoutes,
-        onBeforeRouteHook,
-        pages: pageConfigsUserFriendly,
-        config: globalConfig.config
-    };
-    assertV1Design(
-    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
-    pageConfigs.length > 0, pageFilesAll);
-    return userFiles;
-}
 function assertViteManifest(manifest) {
     assert(isPlainObject(manifest));
     /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/vikejs/vike/issues/769
@@ -326,10 +243,7 @@ function assertViteManifest(manifest) {
 }
 async function loadBuildEntry(outDir) {
     debug('loadBuildEntry()');
-    if (globalObject.userFiles) {
-        assert(globalObject.buildInfo);
-        assert(globalObject.assetsManifest);
-        assert(globalObject.buildEntry);
+    if (globalObject.globalContext) {
         return;
     }
     if (!globalObject.buildEntry) {
@@ -342,20 +256,18 @@ async function loadBuildEntry(outDir) {
             globalObject.buildEntry = globalObject.buildEntryPrevious;
         }
         assert(globalObject.buildEntry);
+        // If using `inject` then dist/server/index.js imports dist/server/entry.js and loadBuildEntry() isn't needed.
+        // If dist/server/entry.js isn't imported then this means the user is running the original server entry `$ ts-node server/index.ts`.
         assertWarning(
-        // vike-server => `vitePluginServerEntry.inject === true`
-        // vike-node => `vitePluginServerEntry.inject === [ 'index' ]`
-        globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject !== true, 
-        /* TO-DO/eventually:
-        !!globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject,
-        */
-        `Run the built server entry (e.g. ${pc.cyan('$ node dist/server/index.mjs')}) instead of the original server entry (e.g. ${pc.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
+        // vike-server => `inject === true`
+        // vike-node => `inject === [ 'index' ]` => we don't show the warning to vike-node users (I don't remember why).
+        globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject !== true || globalObject.isPrerendering, `Run the built server entry (e.g. ${pc.cyan('$ node dist/server/index.mjs')}) instead of the original server entry (e.g. ${pc.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
     }
     const { buildEntry } = globalObject;
     assertBuildEntry(buildEntry);
     globalObject.assetsManifest = buildEntry.assetsManifest;
     globalObject.buildInfo = buildEntry.buildInfo;
-    await setUserFiles(buildEntry.virtualFileExports);
+    await setGlobalContext(buildEntry.virtualFileExports);
 }
 async function setGlobalContext_buildEntry(buildEntry) {
     debug('setGlobalContext_buildEntry()');
@@ -415,15 +327,80 @@ async function updateUserFiles() {
     // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
     if (viteDevServer !== globalObject.viteDevServer)
         return;
-    await setUserFiles(virtualFileExports);
+    await setGlobalContext(virtualFileExports);
     resolve();
 }
-async function setUserFiles(virtualFileExports) {
-    globalObject.pageConfigsRuntime = getPageConfigsRuntime(virtualFileExports);
-    const userFiles = await getUserFiles();
-    globalObject.userFiles = userFiles;
-    defineGlobalContext();
+async function setGlobalContext(virtualFileExports) {
+    const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext);
+    assertV1Design(
+    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
+    globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);
+    // Public usage
+    globalObject.globalContext_public = makePublic(globalContext);
     assertGlobalContextIsDefined();
+    onSetupRuntime();
+    // Never actually used, only used for TypeScript `ReturnType<typeof setGlobalContext>`
+    return globalContext;
+}
+async function addGlobalContext(globalContext) {
+    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
+    const globalContextBase = {
+        isClientSide: false,
+        _pageRoutes: pageRoutes,
+        _onBeforeRouteHook: onBeforeRouteHook
+    };
+    const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction } = globalObject;
+    assert(typeof isProduction === 'boolean');
+    if (!isProduction) {
+        assert(viteDevServer);
+        assert(globalContext); // main common requirement
+        assert(viteConfig);
+        assert(viteConfigRuntime);
+        assert(!isPrerendering);
+        return {
+            ...globalContext,
+            ...globalContextBase,
+            ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
+            _isProduction: false,
+            _isPrerendering: false,
+            assetsManifest: null,
+            _viteDevServer: viteDevServer,
+            viteConfig,
+            viteConfigRuntime
+        };
+    }
+    else {
+        assert(globalObject.buildEntry);
+        assert(globalContext); // main common requiement
+        const { buildInfo, assetsManifest } = globalObject;
+        assert(buildInfo);
+        assert(assetsManifest);
+        const globalContextBase2 = {
+            ...globalContext,
+            ...globalContextBase,
+            ...resolveBaseRuntime(buildInfo.viteConfigRuntime, globalContext.config),
+            _isProduction: true,
+            assetsManifest,
+            _viteDevServer: null,
+            viteConfigRuntime: buildInfo.viteConfigRuntime,
+            _usesClientRouter: buildInfo.usesClientRouter
+        };
+        if (isPrerendering) {
+            assert(viteConfig);
+            return {
+                ...globalContextBase2,
+                _isPrerendering: true,
+                viteConfig
+            };
+        }
+        else {
+            return {
+                ...globalContextBase2,
+                _isPrerendering: false,
+                viteConfig: null
+            };
+        }
+    }
 }
 function clearGlobalContext() {
     debug('clearGlobalContext()');

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

@@ -1,7 +1,7 @@
 import { isFontFallback } from '../../renderPage/isFontFallback.js';
 export { getHtmlTags };
 import { assert, assertWarning, assertUsage, isObject, freezePartial } from '../../utils.js';
-import { serializePageContextClientSide } from '../serializePageContextClientSide.js';
+import { getGlobalContextClientSerialized, getPageContextClientSerialized } from '../serializeContext.js';
 import { sanitizeJson } from './sanitizeJson.js';
 import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
 import { mergeScriptTags } from './mergeScriptTags.js';
@@ -9,11 +9,12 @@ import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
 import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValueRuntime.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
+import { htmlElementId_globalContext, htmlElementId_pageContext } from '../../../../shared/htmlElementIds.js';
 const stamp = '__injectFilterEntry';
 async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
     assert([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
-    const { isProduction } = pageContext._globalContext;
+    const { _isProduction: isProduction } = pageContext._globalContext;
     const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
     const injectFilterEntries = [];
     pageAssets
@@ -119,14 +120,21 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
         //   - https://github.com/vikejs/vike-vue/issues/85
         assertWarning(false, "We recommend against using HTML streaming and a pageContext promise (https://vike.dev/streaming#initial-data-after-stream-end) at the same time, because progressive hydration (https://vike.dev/streaming#progressive-rendering) won't work.", { onlyOnce: true });
     }
-    // <script id="vike_pageContext" type="application/json">
     if (!isHtmlOnly) {
+        // <script id="vike_pageContext" type="application/json">
         htmlTags.push({
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
             getPageContextJsonScriptTag(pageContext),
             position: positionJavaScriptEntry
         });
+        // <script id="vike_globalContext" type="application/json">
+        htmlTags.push({
+            htmlTag: () => 
+            // Needs to be called after resolvePageContextPromise()
+            getGlobalContextJsonScriptTag(pageContext),
+            position: positionJavaScriptEntry
+        });
     }
     // The JavaScript entry <script> tag
     const scriptEntry = mergeScriptEntries(pageAssets, viteDevScript);
@@ -157,13 +165,18 @@ function mergeScriptEntries(pageAssets, viteDevScript) {
     return scriptTag;
 }
 function getPageContextJsonScriptTag(pageContext) {
-    const pageContextSerialized = sanitizeJson(serializePageContextClientSide(pageContext));
-    const htmlTag = `<script id="vike_pageContext" type="application/json">${pageContextSerialized}</script>`;
+    const pageContextClientSerialized = sanitizeJson(getPageContextClientSerialized(pageContext));
+    const htmlTag = `<script id="${htmlElementId_pageContext}" type="application/json">${pageContextClientSerialized}</script>`;
     // Used by contra.com https://github.com/gajus
     // @ts-expect-error
     pageContext._pageContextHtmlTag = htmlTag;
     return htmlTag;
 }
+function getGlobalContextJsonScriptTag(pageContext) {
+    const globalContextClientSerialized = sanitizeJson(getGlobalContextClientSerialized(pageContext));
+    const htmlTag = `<script id="${htmlElementId_globalContext}" type="application/json">${globalContextClientSerialized}</script>`;
+    return htmlTag;
+}
 function assertInjectFilterEntries(injectFilterEntries) {
     try {
         checkForWrongUsage(injectFilterEntries);

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

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

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

@@ -4,10 +4,10 @@ import pc from '@brillout/picocolors';
 const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
 async function getViteDevScript(pageContext) {
     const globalContext = pageContext._globalContext;
-    if (globalContext.isProduction) {
+    if (globalContext._isProduction) {
         return '';
     }
-    const { viteDevServer } = globalContext;
+    const { _viteDevServer: viteDevServer } = globalContext;
     const fakeHtmlBegin = '<html> <head>'; // White space to test whether user is using a minifier
     const fakeHtmlEnd = '</head><body></body></html>';
     let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;

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

@@ -7,8 +7,8 @@ import type { HtmlPart } from './renderHtml.js';
 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 { GlobalContextInternal } from '../globalContext.js';
+import type { PageContextSerialization } from './serializeContext.js';
+import type { GlobalContextServerInternal } from '../globalContext.js';
 type PageContextInjectAssets = {
     urlPathname: string;
     __getPageAssets: () => Promise<PageAsset[]>;
@@ -22,7 +22,7 @@ type PageContextInjectAssets = {
     _baseServer: string;
     _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
-    _globalContext: GlobalContextInternal;
+    _globalContext: GlobalContextServerInternal;
 } & PageContextSerialization;
 declare function injectHtmlTagsToString(htmlParts: HtmlPart[], pageContext: PageContextInjectAssets & {
     _isStream: false;

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

@@ -0,0 +1,8 @@
+export { getPropVal };
+export { setPropVal };
+export { getPropKeys };
+declare function getPropVal(obj: Record<string, unknown>, prop: string): null | {
+    value: unknown;
+};
+declare function setPropVal(obj: Record<string, unknown>, prop: string, val: unknown): void;
+declare function getPropKeys(prop: string): string[];

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

@@ -0,0 +1,45 @@
+export { getPropVal };
+export { setPropVal };
+export { getPropKeys };
+import { isObject } from '../utils.js';
+// Get a nested property from an object using a dot-separated path such as 'user.id'
+function getPropVal(obj, prop) {
+    const keys = getPropKeys(prop);
+    let value = obj;
+    for (const key of keys) {
+        if (isObject(value) && key in value) {
+            value = value[key];
+        }
+        else {
+            return null; // Property or intermediate property doesn't exist
+        }
+    }
+    return { value };
+}
+// Set a nested property in an object using a dot-separated path such as 'user.id'
+function setPropVal(obj, prop, val) {
+    const keys = getPropKeys(prop);
+    let currentObj = obj;
+    // Creating intermediate objects if necessary
+    for (let i = 0; i <= keys.length - 2; i++) {
+        const key = keys[i];
+        if (!(key in currentObj)) {
+            // Create intermediate object
+            currentObj[key] = {};
+        }
+        if (!isObject(currentObj[key])) {
+            // Skip value upon data structure conflict
+            return;
+        }
+        currentObj = currentObj[key];
+    }
+    // Set the final key to the value
+    const finalKey = keys[keys.length - 1];
+    currentObj[finalKey] = val;
+}
+function getPropKeys(prop) {
+    // Like `prop.split('.')` but with added support for `\` escaping, see getPageContextClientSerialized.spec.ts
+    return prop
+        .split(/(?<!\\)\./) // Split on unescaped dots
+        .map((key) => key.replace(/\\\./g, '.')); // Replace escaped dots with literal dots
+}

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

@@ -71,7 +71,13 @@ async function renderHtmlStream(streamOriginal, injectString, pageContext, onErr
             return injectAtStreamAfterFirstChunk();
         };
     }
+    let makeClosableAgain = () => { };
+    if (isStreamFromReactStreamingPackage(streamOriginal)) {
+        // Make sure Vike injects its HTML fragments, such as `<script id="vike_pageContext" type="application/json">`, before the stream is closed
+        makeClosableAgain = streamOriginal.doNotClose();
+    }
     const streamWrapper = await processStream(streamOriginal, processStreamOptions);
+    makeClosableAgain();
     return streamWrapper;
 }
 function isTemplateWrapped(something) {
@@ -192,7 +198,7 @@ function renderTemplate(templateContent, pageContext) {
             }
         }
         {
-            const { isProduction } = pageContext._globalContext;
+            const { _isProduction: 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/html/{serializePageContextClientSide.d.ts → serializeContext.d.ts}

@@ -1,7 +1,7 @@
-export { serializePageContextClientSide };
-export { serializePageContextAbort };
+export { getPageContextClientSerialized };
+export { getPageContextClientSerializedAbort };
+export { getGlobalContextClientSerialized };
 export type { PageContextSerialization };
-export { getPropKeys };
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { UrlRedirect } from '../../../shared/route/abort.js';
 type PageContextSerialization = {
@@ -12,13 +12,14 @@ type PageContextSerialization = {
     is404: null | boolean;
     pageProps?: Record<string, unknown>;
     _pageContextInit: Record<string, unknown>;
+    globalContext: Record<string, any>;
 };
-declare function serializePageContextClientSide(pageContext: PageContextSerialization): string;
-declare function serializePageContextAbort(pageContext: Record<string, unknown> & ({
+declare function getPageContextClientSerialized(pageContext: PageContextSerialization): string;
+declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization): string;
+declare function getPageContextClientSerializedAbort(pageContext: Record<string, unknown> & ({
     _urlRedirect: UrlRedirect;
 } | {
     _urlRewrite: string;
 } | {
     abortStatusCode: number;
 })): string;
-declare function getPropKeys(prop: string): string[];