vike 0.4.218 → 0.4.220

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.js

@@ -1,4 +1,5 @@
 export { serializeConfigValues };
+export { getConfigValuesBase };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { assert, assertUsage, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
@@ -12,77 +13,45 @@ const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 // - vike/shared/page-configs/serialize/parsePageConfigs.ts
 // - parsePageConfigs() is loaded on both the client- and server-side.
 assertIsNotProductionRuntime();
-function serializeConfigValues(pageConfig, importStatements, isEnvMatch, { isEager }, tabspace) {
+function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspace, isEager) {
     const lines = [];
     tabspace += '  ';
-    Object.entries(pageConfig.configValuesComputed ?? {}).forEach(([configName, configValuesComputed]) => {
-        if (!isEnvMatch(configValuesComputed.configEnv))
-            return;
-        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
-        if (pageConfig.configValueSources[configName])
-            return;
-        const valueData = serializeWithJson(configValuesComputed.value, configName, null, importStatements);
-        const configValueBase = {
-            type: 'computed',
-            definedAtData: null
-        };
-        serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
-    });
-    Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
-        const configDef = pageConfig.configDefinitions[configName];
-        assert(configDef);
-        if (isEager !== !!configDef.eager)
-            return;
-        if (!configDef.cumulative) {
-            const configValueSource = sources[0];
-            assert(configValueSource);
-            assert(sources.slice(1).every((s) => s.isOverriden === true));
-            if (!isEnvMatch(configValueSource.configEnv))
-                return;
-            const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
-            const configValueBase = {
-                type: 'standard',
-                definedAtData: definedAtFile
-            };
+    getConfigValuesBase(pageConfig, isEnvMatch, isEager).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            assert('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            const valueData = getValueSerializedWithJson(value, configName, configValueBase.definedAtData, importStatements);
             serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
         }
-        else {
+        if (entry.configValueBase.type === 'standard') {
+            assert('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            const valueData = getValueSerializedFromSource(sourceRelevant, configName, importStatements);
+            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            assert('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
             const valueDataList = [];
-            const definedAtData = [];
-            sources
-                .filter((s) => !s.isOverriden)
-                .forEach((configValueSource) => {
-                if (!isEnvMatch(configValueSource.configEnv))
-                    return;
-                const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+            sourcesRelevant.forEach((source) => {
+                const valueData = getValueSerializedFromSource(source, configName, importStatements);
                 valueDataList.push(valueData);
-                definedAtData.push(definedAtFile);
             });
-            if (valueDataList.length === 0)
-                return;
-            const configValueBase = {
-                type: 'cumulative',
-                definedAtData
-            };
             serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
         }
     });
     return lines;
 }
-function serializeConfigValueSource(configValueSource, configName, importStatements) {
+function getValueSerializedFromSource(configValueSource, configName, importStatements) {
     assert(configValueSource.isOverriden === false);
     let valueData;
     if ('value' in configValueSource) {
-        valueData = serializeWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
+        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
     }
     else {
-        valueData = serializeWithImport(configValueSource, importStatements);
+        valueData = getValueSerializedWithImport(configValueSource, importStatements);
     }
-    const definedAtFile = {
-        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
-    };
-    return { valueData, definedAtFile };
+    return valueData;
 }
 function serializeConfigValue(configValueBase, valueData, configName, lines, tabspace) {
     lineAdd(`[${JSON.stringify(configName)}]: {`);
@@ -126,7 +95,7 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
         tabspace = tabspace.slice(2);
     }
 }
-function serializeWithImport(configValueSource, importStatements) {
+function getValueSerializedWithImport(configValueSource, importStatements) {
     assert(!configValueSource.valueIsFilePath);
     const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
     assert(valueIsImportedAtRuntime);
@@ -139,7 +108,7 @@ function serializeWithImport(configValueSource, importStatements) {
         valueAsJsCode: importName
     };
 }
-function serializeWithJson(value, configName, definedAtData, importStatements) {
+function getValueSerializedWithJson(value, configName, definedAtData, importStatements) {
     const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements);
     return {
         type: 'js-serialized',
@@ -196,3 +165,59 @@ function logJsonSerializeError(err, configName, definedAtData) {
     assert(configValueFilePathToShowToUser);
     assertUsage(false, `${pc.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
 }
+function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
+    const fromComputed = Object.entries(pageConfig.configValuesComputed ?? {}).map(([configName, valueInfo]) => {
+        if (!isEnvMatch(valueInfo.configEnv))
+            return 'SKIP';
+        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return 'SKIP';
+        const configValueBase = {
+            type: 'computed',
+            definedAtData: null
+        };
+        return { configValueBase, value: valueInfo.value, configName };
+    });
+    const fromSources = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
+        const configDef = pageConfig.configDefinitions[configName];
+        assert(configDef);
+        if (isEager !== null && isEager !== !!configDef.eager)
+            return 'SKIP';
+        if (!configDef.cumulative) {
+            const source = sources[0];
+            assert(source);
+            assert(sources.slice(1).every((s) => s.isOverriden === true));
+            if (!isEnvMatch(source.configEnv))
+                return 'SKIP';
+            const definedAtFile = getDefinedAtFileSource(source);
+            const configValueBase = {
+                type: 'standard',
+                definedAtData: definedAtFile
+            };
+            return { configValueBase, sourceRelevant: source, configName };
+        }
+        else {
+            const sourcesRelevant = sources.filter((source) => !source.isOverriden && isEnvMatch(source.configEnv));
+            if (sourcesRelevant.length === 0)
+                return 'SKIP';
+            const definedAtData = [];
+            sourcesRelevant.forEach((source) => {
+                const definedAtFile = getDefinedAtFileSource(source);
+                definedAtData.push(definedAtFile);
+            });
+            const configValueBase = {
+                type: 'cumulative',
+                definedAtData
+            };
+            return { configValueBase, sourcesRelevant, configName };
+        }
+    });
+    return [...fromComputed, ...fromSources].filter((r) => r !== 'SKIP');
+}
+function getDefinedAtFileSource(source) {
+    const definedAtFile = {
+        filePathToShowToUser: source.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: source.definedAtFilePath.fileExportPathToShowToUser
+    };
+    return definedAtFile;
+}

package/dist/esm/shared/route/executeGuardHook.d.ts

@@ -1,7 +1,7 @@
 export { executeGuardHook };
-import type { PageContextExports, PageFile } from '../getPageFiles.js';
+import type { PageConfigUserFriendly, PageFile } from '../getPageFiles.js';
 import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
-declare function executeGuardHook<T extends PageContextExports & {
+declare function executeGuardHook<T extends PageConfigUserFriendly & {
     pageId: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];

package/dist/esm/shared/route/loadPageRoutes.js

@@ -3,7 +3,7 @@ import { isErrorPageId } from '../error-page.js';
 import { assert, assertUsage, hasProp, slice } from './utils.js';
 import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
 import { isCallable } from '../utils.js';
-import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
 import { getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
 import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/getHook.js';

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

@@ -8,7 +8,7 @@ export { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
 import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from './getPageContextUrlComputed.js';
-import type { ConfigEntries, ExportsAll, From, Source, Sources } from './getPageFiles/getExports.js';
+import type { ConfigEntries, ExportsAll, From, Source, Sources } from './page-configs/getPageConfigUserFriendly.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';

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

@@ -22,3 +22,4 @@ export * from '../utils/escapeRegex.js';
 export * from '../utils/isArray.js';
 export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
+export * from '../utils/isScriptFile.js';

package/dist/esm/shared/utils.js

@@ -26,3 +26,4 @@ export * from '../utils/escapeRegex.js';
 export * from '../utils/isArray.js';
 export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
+export * from '../utils/isScriptFile.js';

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

@@ -10,7 +10,7 @@ export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.
 export type { Config, ConfigMeta as Meta, ImportString, DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync, KeepScrollPosition } from '../shared/page-configs/Config.js';
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
-export type { ConfigEntries } from '../shared/getPageFiles/getExports.js';
+export type { ConfigEntries } from '../shared/page-configs/getPageConfigUserFriendly.js';
 export type { UrlPublic as Url } from '../utils/parseUrl.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';
 export { defineConfig } from './defineConfig.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.218";
+export declare const PROJECT_VERSION: "0.4.220";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.218';
+export const PROJECT_VERSION = '0.4.220';

package/dist/esm/utils/assert.js

@@ -30,6 +30,7 @@ const globalObject = getGlobalObject('utils/assert.ts', {
 assertSingleInstance_onAssertModuleLoad();
 const projectTag = `[vike]`;
 const projectTagWithVersion = `[vike@${projectInfo.projectVersion}]`;
+const bugTag = 'Bug';
 const numberOfStackTraceLinesToRemove = 2;
 function assert(condition, debugInfo) {
     if (condition)
@@ -49,7 +50,7 @@ function assert(condition, debugInfo) {
         .filter(Boolean)
         .join(' ');
     errMsg = addWhitespace(errMsg);
-    errMsg = addPrefixAssertType(errMsg, 'Bug');
+    errMsg = addPrefixAssertType(errMsg, bugTag);
     errMsg = addPrefixProjctName(errMsg, true);
     const internalError = createErrorWithCleanStackTrace(errMsg, numberOfStackTraceLinesToRemove);
     globalObject.onBeforeLog?.();
@@ -160,7 +161,7 @@ function getAssertErrMsg(thing) {
         const showVikeVersion = tag === projectTagWithVersion;
         const errStackPrefix = `Error: ${tag}`;
         if (errStack?.startsWith(errStackPrefix)) {
-            if (globalObject.showStackTraceList.has(thing)) {
+            if (globalObject.showStackTraceList.has(thing) || isBug(thing)) {
                 const assertMsg = errStack.slice(errStackPrefix.length);
                 return { assertMsg, showVikeVersion };
             }
@@ -179,7 +180,7 @@ function overwriteAssertProductionLogger(logger) {
     globalObject.logger = logger;
 }
 function isBug(err) {
-    return !String(err).includes('[Bug]');
+    return String(err).includes(`[${bugTag}]`);
 }
 function setAlwaysShowStackTrace() {
     globalObject.alwaysShowStackTrace = true;

package/dist/esm/utils/assertSetup.js

@@ -28,16 +28,19 @@ function onSetupRuntime() {
         debug('assertSetup()', new Error().stack);
     if (isTest())
         return;
+    assertNodeEnvIsNotUndefinedString();
     if (!isViteLoaded()) {
         // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
-        assertWarning(!isNodeEnvDev(), `The ${getEnvDescription()}, which seems contradictory because the environment seems to be a production environment (Vite isn't loaded), see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        assertWarning(!isNodeEnvDev(), `The ${getEnvDescription()}, which is contradictory because the environment seems to be a production environment (Vite isn't loaded), see https://vike.dev/NODE_ENV`, { onlyOnce: true });
         assertUsage(!setup.vikeVitePlugin, "Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.");
         // This assert() one of the main goal of this file: it ensures assertIsNotProductionRuntime()
         assert(!setup.shouldNotBeProduction);
     }
     else {
-        // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
-        assertWarning(isNodeEnvDev() || setup.vitePreviewServer || setup.isPrerendering, `The ${getEnvDescription()}, but Vite is loaded which is prohibited in production, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        if (!setup.vitePreviewServer && !setup.isPrerendering) {
+            // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
+            assertWarning(isNodeEnvDev(), `The ${getEnvDescription()}, but Vite is loaded which is prohibited in production, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        }
         // These two assert() calls aren't that interesting
         assert(setup.vikeVitePlugin);
         assert(setup.shouldNotBeProduction);
@@ -57,7 +60,7 @@ function onSetupBuild() {
 }
 function onSetupPrerender() {
     markSetup_isPrerendering();
-    if (getNodeEnvValue())
+    if (getNodeEnv())
         assertUsageNodeEnvIsNotDev('pre-rendering');
     setNodeEnvProduction();
 }
@@ -66,7 +69,7 @@ function isViteLoaded() {
     return setup.viteDevServer || setup.vitePreviewServer || setup.isViteDev !== undefined;
 }
 function isTest() {
-    return isVitest() || getNodeEnvValue() === 'test';
+    return isVitest() || isNodeEnv('test');
 }
 // Called by Vite hook configureServer()
 function markSetup_viteDevServer() {
@@ -105,26 +108,54 @@ function assertUsageNodeEnvIsNotDev(operation) {
     assertWarning(false, `The ${getEnvDescription()} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
 }
 function getEnvDescription() {
-    const nodeEnv = getNodeEnvValue();
-    const isDev = isNodeEnvDev();
-    const envType = `${(isDev ? 'development' : 'production')} environment`;
-    const nodeEnvDesc = `environment is set to be a ${pc.bold(envType)} by ${pc.cyan(`process.env.NODE_ENV===${JSON.stringify(nodeEnv)}`)}`;
+    const envType = `${(isNodeEnvDev() ? 'development' : 'production')} environment`;
+    const nodeEnvDesc = `environment is set to be a ${pc.bold(envType)} by ${pc.cyan(`process.env.NODE_ENV===${JSON.stringify(getNodeEnv())}`)}`;
     return nodeEnvDesc;
 }
+// For example, Wrangler bug replaces `process.env.NODE_ENV` with `"undefined"`
+// https://github.com/cloudflare/workers-sdk/issues/7886
+function assertNodeEnvIsNotUndefinedString() {
+    const nodeEnv = getNodeEnv();
+    assertWarning(nodeEnv !== 'undefined', `${pc.cyan('process.env.NODE_ENV==="undefined"')} which is unexpected: ${pc.cyan('process.env.NODE_ENV')} is allowed to be the *value* ${pc.cyan('undefined')} (i.e. ${pc.cyan('process.env.NODE_ENV===undefined')}) but it shouldn't be the *string* ${pc.cyan('"undefined"')} ${pc.underline('https://vike.dev/NODE_ENV')}`, { onlyOnce: true });
+}
 function isNodeEnvDev() {
-    const nodeEnv = getNodeEnvValue();
+    const nodeEnv = getNodeEnv();
     // That's quite strict, let's see if some user complains
-    return !nodeEnv || ['development', 'dev'].includes(nodeEnv);
+    return nodeEnv === undefined || isNodeEnv(['development', 'dev', '']);
+}
+function isNodeEnv(value) {
+    const values = Array.isArray(value) ? value : [value];
+    const nodeEnv = getNodeEnv();
+    return nodeEnv !== undefined && values.includes(nodeEnv.toLowerCase());
 }
-function getNodeEnvValue() {
-    if (typeof process === 'undefined')
-        return null;
-    return process.env.NODE_ENV?.toLowerCase();
+function getNodeEnv() {
+    let val;
+    try {
+        val = process.env.NODE_ENV;
+    }
+    catch {
+        return undefined;
+    }
+    /*
+    // Should we show the following warning? So far I don't think so because of the following. Maybe we can show it once we enable users to disable warnings.
+    // - The warning isn't always actionable, e.g. if it's a tool that dynamically sets `process.env.NODE_ENV`.
+    // - We assume that tools use `process.env.NODE_ENV` and not someting like `const { env } = process; env.NODE_ENV`. Thus, in practice, `val` overrides `val2` so having `val!==val2` isn't an issue.
+    {
+      const val2 = process.env['NODE' + '_ENV']
+      if (val2)
+        assertWarning(
+          val === val2,
+          `Dynamically setting process.env.NODE_ENV to ${val2} hasn't any effect because process.env.NODE_ENV is being statically replaced to ${val}.`,
+          { onlyOnce: true }
+        )
+    }
+    //*/
+    return val;
 }
 function setNodeEnvProduction() {
     // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
     const proc = process;
     const { env } = proc;
     env.NODE_ENV = 'production';
-    assert(getNodeEnvValue() === 'production');
+    assert(isNodeEnv('production'));
 }

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

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugActivated };
 export type { Debug };
-declare const flags: readonly ["vike:error", "vike:extractAssets", "vike:extractExportNames", "vike:glob", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:routing", "vike:setup", "vike:stream", "vike:virtual-files", "vike:esbuild-resolve"];
+declare const flags: readonly ["vike:error", "vike:extractAssets", "vike:extractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:routing", "vike:setup", "vike:stream", "vike:virtual-files", "vike:esbuild-resolve"];
 type Flag = (typeof flags)[number];
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {

package/dist/esm/utils/debug.js

@@ -16,6 +16,7 @@ const flags = [
     'vike:extractAssets',
     'vike:extractExportNames',
     'vike:glob',
+    'vike:globalContext',
     'vike:log',
     'vike:optimizeDeps',
     'vike:outDir',
@@ -28,7 +29,7 @@ const flags = [
     'vike:esbuild-resolve'
 ];
 const flagRegex = /\bvike:[a-zA-Z-]+/g;
-assertDEBUG();
+assertFlagsActivated();
 function createDebugger(flag, optionsGlobal) {
     checkType(flag);
     assert(flags.includes(flag));
@@ -71,8 +72,8 @@ function debug_(flag, options, ...msgs) {
 function isDebugActivated(flag) {
     checkType(flag);
     assert(flags.includes(flag));
-    const DEBUG = getDEBUG();
-    const isActivated = DEBUG?.includes(flag) ?? false;
+    const flagsActivated = getFlagsActivated();
+    const isActivated = flagsActivated.includes(flag);
     return isActivated;
 }
 function formatMsg(info, options, padding, position) {
@@ -135,13 +136,17 @@ function replaceFunctionSerializer(_key, value) {
     }
     return value;
 }
-function assertDEBUG() {
-    const DEBUG = getDEBUG() ?? '';
-    const flagsActivated = DEBUG.match(flagRegex) ?? [];
+function assertFlagsActivated() {
+    const flagsActivated = getFlagsActivated();
     flagsActivated.forEach((flag) => {
         assertUsage(flags.includes(flag), `Unknown DEBUG flag ${pc.cyan(flag)}. Valid flags:\n${flags.map((f) => `  ${pc.cyan(f)}`).join('\n')}`);
     });
 }
+function getFlagsActivated() {
+    const DEBUG = getDEBUG() ?? '';
+    const flagsActivated = DEBUG.match(flagRegex) ?? [];
+    return flagsActivated;
+}
 function getDEBUG() {
     let DEBUG;
     // - `process` can be undefined in edge workers

package/dist/esm/utils/getGlobalObject.js

@@ -1,8 +1,6 @@
 export { getGlobalObject };
 export { assertIsSingleModuleInstance };
 import { assert } from './assert.js';
-import { projectInfo } from './projectInfo.js';
-const projectKey = `_${projectInfo.projectName.toLowerCase()}`;
 /** Share information across module instances. */
 function getGlobalObject(
 // We use the filename (or file path) as key. There should be only one getGlobalObject() usage per file. Thus the key should be unique, assuming the filename (or file path) is unique.
@@ -19,6 +17,7 @@ key) {
     assert(!(key in globalObjects));
 }
 function getGlobalObjects() {
+    const projectKey = '_vike';
     // @ts-ignore
     const globalObjects = (globalThis[projectKey] = globalThis[projectKey] || {});
     return globalObjects;

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

@@ -0,0 +1 @@
+export declare function objectReplace(obj: object, objNew: object, except?: string[]): void;

package/dist/esm/utils/objectReplace.js

@@ -0,0 +1,6 @@
+export function objectReplace(obj, objNew, except) {
+    Object.keys(obj)
+        .filter((key) => !except?.includes(key))
+        .forEach((key) => delete obj[key]);
+    Object.assign(obj, objNew);
+}

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

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.218";
+    projectVersion: "0.4.220";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.218",
+  "version": "0.4.220",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -108,14 +108,6 @@
       "types": "./dist/esm/node/runtime/page-files/setup.d.ts",
       "default": "./dist/esm/node/runtime/page-files/setup.js"
     },
-    "./__internal/loadImportBuild": {
-      "worker": "./dist/esm/node/runtime/globalContext/loadImportBuild.js",
-      "edge-light": "./dist/esm/node/runtime/globalContext/loadImportBuild.js",
-      "require": "./dist/cjs/node/runtime/globalContext/loadImportBuild.js",
-      "node": "./dist/esm/node/runtime/globalContext/loadImportBuild.js",
-      "types": "./dist/esm/node/runtime/globalContext/loadImportBuild.d.ts",
-      "default": "./dist/esm/node/runtime/globalContext/loadImportBuild.js"
-    },
     ".": {
       "worker": "./dist/esm/node/runtime/index-deprecated.js",
       "edge-light": "./dist/esm/node/runtime/index-deprecated.js",
@@ -131,7 +123,7 @@
     "@brillout/json-serializer": "^0.5.15",
     "@brillout/picocolors": "^1.0.15",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.5.6",
+    "@brillout/vite-plugin-server-entry": "^0.5.8",
     "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",
@@ -236,7 +228,6 @@
     "./dist-cjs-fixup.mjs",
     "./getPageContext.js",
     "./__internal.js",
-    "./__internal/loadImportBuild.js",
     "./__internal/setup.js",
     "./modifyUrl.js",
     "./plugin.js",
@@ -255,9 +246,9 @@
     "@types/resolve": "^1.20.6",
     "@types/semver": "^7.5.8",
     "@types/source-map-support": "^0.5.10",
-    "react-streaming": "^0.3.44",
+    "react-streaming": "^0.3.47",
     "rimraf": "^5.0.5",
-    "typescript": "^5.6.2",
+    "typescript": "^5.7.3",
     "vite": "^6.0.5"
   },
   "scripts": {

package/__internal/loadImportBuild.js

@@ -1,3 +0,0 @@
-// Some tools still need this as of January 2025
-export * from '../dist/esm/node/runtime/globalContext/loadImportBuild.js'
-export { default } from '../dist/esm/node/runtime/globalContext/loadImportBuild.js'