vike 0.4.237-commit-8749e81 → 0.4.237-commit-92dc549

package/dist/esm/node/vite/shared/getOutDirs.js

@@ -3,19 +3,22 @@ export { resolveOutDir };
 export { resolveOutDir_configEnvironment };
 import pc from '@brillout/picocolors';
 import { assert, assertPosixPath, assertUsage, createDebugger, pathJoin, toPosixPath } from '../utils.js';
-import { isViteServerBuild, isViteServerBuild_withoutEnv } from './isViteServerBuild.js';
+import { isViteServerSide, isViteServerSide_withoutEnv } from './isViteServerSide.js';
 const debug = createDebugger('vike:outDir');
 function getOutDirs(configGlobal, viteEnv) {
     debug('getOutDirs()', new Error().stack);
     const outDir = getOutDirFromResolvedConfig(configGlobal);
     assertOutDirResolved(outDir, configGlobal, viteEnv);
     const outDirs = getOutDirsAll(outDir, configGlobal.root);
+    assertNormalization(outDirs.outDirRoot);
+    assertNormalization(outDirs.outDirClient);
+    assertNormalization(outDirs.outDirServer);
     return outDirs;
 }
 function resolveOutDir_configEnvironment(configGlobal, envName, configEnv) {
     assert(configGlobal && envName && configEnv);
     const viteEnv = { name: envName, config: configEnv };
-    const isServerSide = isViteServerBuild(configGlobal, viteEnv);
+    const isServerSide = isViteServerSide(configGlobal, viteEnv);
     return resolveOutDir(configEnv, isServerSide);
 }
 /** Appends `client/` or `server/` to `config.build.outDir` */
@@ -90,9 +93,9 @@ function getOutDirsAllFromRootNormalized(outDirRoot, root) {
 }
 function assertNormalization(outDirAny) {
     assertPosixPath(outDirAny);
-    assert(outDirIsAbsolutePath(outDirAny));
-    assert(outDirAny.endsWith('/'));
-    assert(!outDirAny.endsWith('//'));
+    assert(outDirIsAbsolutePath(outDirAny), outDirAny);
+    assert(outDirAny.endsWith('/'), outDirAny);
+    assert(!outDirAny.endsWith('//'), outDirAny);
 }
 function isOutDirRoot(outDirRot) {
     const p = outDirRot.split('/').filter(Boolean);
@@ -111,7 +114,7 @@ function assertOutDirResolved(outDir, configGlobal, viteEnv) {
     assert('/client'.length === '/server'.length);
     const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
     const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
-    if (isViteServerBuild_withoutEnv(configGlobal, viteEnv)) {
+    if (isViteServerSide_withoutEnv(configGlobal, viteEnv)) {
         assertUsage(outDir.endsWith('/server'), wrongUsage);
     }
     else {

package/dist/esm/node/vite/shared/isViteServerSide.d.ts

@@ -0,0 +1,18 @@
+export { isViteServerSide };
+export { isViteClientSide };
+export { isViteServerSide_withoutEnv };
+export { isViteServerSide_onlySsrEnv };
+export { isViteServerSide_extraSafe };
+export type { ViteEnv };
+import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig } from 'vite';
+type ViteEnv = {
+    name?: string;
+    config: EnvironmentOptions | Environment['config'];
+};
+declare function isViteServerSide_withoutEnv(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv): boolean;
+declare function isViteServerSide(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
+declare function isViteClientSide(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerSide_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerSide_extraSafe(config: ResolvedConfig, options: {
+    ssr?: boolean;
+} | undefined, viteEnv: ViteEnv): boolean;

package/dist/esm/node/vite/shared/{isViteServerBuild.js → isViteServerSide.js}

@@ -1,12 +1,10 @@
-// TODO/now: rename to isViteServerSide
-export { isViteServerBuild };
-// TODO/now: rename to isViteClientSide
-export { isViteClientBuild };
-export { isViteServerBuild_withoutEnv };
-export { isViteServerBuild_onlySsrEnv };
-export { isViteServerBuild_extraSafe };
+export { isViteServerSide };
+export { isViteClientSide };
+export { isViteServerSide_withoutEnv };
+export { isViteServerSide_onlySsrEnv };
+export { isViteServerSide_extraSafe };
 import { assert } from '../../../utils/assert.js';
-function isViteServerBuild_withoutEnv(configGlobal, viteEnv) {
+function isViteServerSide_withoutEnv(configGlobal, viteEnv) {
     assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
     const isServerSide1 = !viteEnv?.config.consumer ? null : viteEnv.config.consumer !== 'client';
     const isServerSide2 = !viteEnv?.name ? null : viteEnv.name !== 'client'; // I can't think of a use case for creating another client-side environment
@@ -41,23 +39,23 @@ function isViteServerBuild_withoutEnv(configGlobal, viteEnv) {
     }
     return isServerSide4;
 }
-function isViteServerBuild(configGlobal, viteEnv) {
-    return isViteServerBuild_withoutEnv(configGlobal, viteEnv);
+function isViteServerSide(configGlobal, viteEnv) {
+    return isViteServerSide_withoutEnv(configGlobal, viteEnv);
 }
-function isViteClientBuild(configGlobal, viteEnv) {
-    return !isViteServerBuild(configGlobal, viteEnv);
+function isViteClientSide(configGlobal, viteEnv) {
+    return !isViteServerSide(configGlobal, viteEnv);
 }
 // Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
-function isViteServerBuild_onlySsrEnv(configGlobal, viteEnv) {
-    return viteEnv ? viteEnv.name === 'ssr' : isViteServerBuild(configGlobal, viteEnv);
+function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
+    return viteEnv.name ? viteEnv.name === 'ssr' : isViteServerSide(configGlobal, viteEnv);
 }
 // Vite is quite messy about setting config.build.ssr — for security purposes, we use an extra safe implementation with lots of assertions, which is needed for the .client.js and .server.js guarantee.
-function isViteServerBuild_extraSafe(config, options, viteEnv) {
+function isViteServerSide_extraSafe(config, options, viteEnv) {
     if (config.command === 'build') {
         const res = config.build.ssr;
         assert(typeof res === 'boolean');
         assert(res === options?.ssr || options?.ssr === undefined);
-        assert(res === isViteServerBuild(config, viteEnv));
+        assert(res === isViteServerSide(config, viteEnv));
         return res;
     }
     else {
@@ -66,7 +64,7 @@ function isViteServerBuild_extraSafe(config, options, viteEnv) {
         /* This assertion can fail, seems to be a Vite bug? It's very unexpected.
         if (typeof config.build.ssr === 'boolean') assert(res === config.build.ssr)
         */
-        assert(res === isViteServerBuild(config, viteEnv));
+        assert(res === isViteServerSide(config, viteEnv));
         return res;
     }
 }

package/dist/esm/node/vite/shared/loggerVite/removeSuperfluousViteLog.js

@@ -1,11 +1,13 @@
 export { removeSuperfluousViteLog };
 export { removeSuperfluousViteLog_enable };
 export { removeSuperfluousViteLog_disable };
-import { assert } from '../../utils.js';
+import { assert, getGlobalObject } from '../../utils.js';
+const globalObject = getGlobalObject('removeSuperfluousViteLog.ts', {
+    enabled: false,
+});
 const superfluousLog = 'Forced re-optimization of dependencies';
-let enabled = false;
 function removeSuperfluousViteLog(msg) {
-    if (!enabled) {
+    if (!globalObject.enabled) {
         return false;
     }
     if (msg.toLowerCase().includes('forced') && msg.toLowerCase().includes('optimization')) {
@@ -15,8 +17,8 @@ function removeSuperfluousViteLog(msg) {
     return false;
 }
 function removeSuperfluousViteLog_enable() {
-    enabled = true;
+    globalObject.enabled = true;
 }
 function removeSuperfluousViteLog_disable() {
-    enabled = false;
+    globalObject.enabled = false;
 }

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.d.ts

@@ -4,9 +4,10 @@ export type { ConfigDefinitions };
 export type { ConfigDefinitionsInternal };
 export type { ConfigDefinitionInternal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath, PageConfigBuildTime } from '../../../../types/PageConfig.js';
+import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath } from '../../../../types/PageConfig.js';
 import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../types/Config.js';
 import { type ConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
+import type { PageConfigBuildTimeBeforeComputed } from '../resolveVikeConfigInternal.js';
 /** The meta definition of a config.
  *
  * https://vike.dev/meta
@@ -75,7 +76,7 @@ type ConfigEffect = (config: {
 }) => Config | undefined;
 /** For Vike internal use */
 type ConfigDefinitionInternal = Omit<ConfigDefinition_, 'env'> & {
-    _computed?: (pageConfig: Omit<PageConfigBuildTime, 'configValuesComputed'>) => unknown;
+    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
     _valueIsFilePath?: true;
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     env: ConfigEnvInternal;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -1,7 +1,7 @@
 export { configDefinitionsBuiltIn };
 import { assert, assertUsage } from '../../utils.js';
 import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
-import { getConfigValueSourcesRelevant } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+import { getConfigValueSourceRelevantAnyEnv, getConfigValueSourcesRelevant, isConfigSourceValueNull, } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -108,7 +108,9 @@ const configDefinitionsBuiltIn = {
             }, pageConfig))
                 .flat(1)
                 // Server-only
-                .filter((source) => !source.configEnv.client);
+                .filter((source) => !source.configEnv.client)
+                // Config value isn't `null`
+                .filter((source) => !isConfigSourceValueNull(source));
             return sources.length > 0;
         },
     },
@@ -120,22 +122,19 @@ const configDefinitionsBuiltIn = {
         env: { server: true, client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const { configValueSources } = pageConfig;
             {
-                const source = getConfigValueSource(configValueSources, 'clientHooks');
+                const source = getConfigValueSourceRelevantAnyEnv('clientHooks', pageConfig);
                 if (source) {
                     assert(source.valueIsLoaded);
-                    if (source.value !== null) {
-                        const { value } = source;
-                        const definedAt = getConfigDefinedAt('Config', 'clientHooks', source.definedAt);
-                        assertUsage(typeof value === 'boolean', `${definedAt} should be a boolean`);
-                        return value;
-                    }
+                    const { value, definedAt } = source;
+                    const configDefinedAt = getConfigDefinedAt('Config', 'clientHooks', definedAt);
+                    assertUsage(typeof value === 'boolean', `${configDefinedAt} should be a boolean`);
+                    return value;
                 }
             }
-            return (isConfigSet(configValueSources, 'onRenderClient') &&
-                isConfigSet(configValueSources, 'Page') &&
-                !!getConfigEnv(configValueSources, 'Page')?.client);
+            return (isConfigSet(pageConfig, 'onRenderClient') &&
+                isConfigSet(pageConfig, 'Page') &&
+                !!getConfigEnv(pageConfig, 'Page')?.client);
         },
     },
     // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
@@ -143,10 +142,7 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const { configValueSources } = pageConfig;
-            return !isConfigSet(configValueSources, 'onBeforeRender')
-                ? null
-                : getConfigEnv(configValueSources, 'onBeforeRender');
+            return !isConfigSet(pageConfig, 'onBeforeRender') ? null : getConfigEnv(pageConfig, 'onBeforeRender');
         },
     },
     // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
@@ -154,8 +150,7 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const { configValueSources } = pageConfig;
-            return !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data');
+            return !isConfigSet(pageConfig, 'data') ? null : getConfigEnv(pageConfig, 'data');
         },
     },
     hooksTimeout: {
@@ -243,11 +238,11 @@ const configDefinitionsBuiltIn = {
         cumulative: true,
     },
 };
-function getConfigEnv(configValueSources, configName) {
-    const configValueSource = getConfigValueSource(configValueSources, configName);
-    if (!configValueSource)
+function getConfigEnv(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    if (!source)
         return null;
-    const { configEnv } = configValueSource;
+    const { configEnv } = source;
     const env = {};
     if (configEnv.client)
         env.client = true;
@@ -255,18 +250,7 @@ function getConfigEnv(configValueSources, configName) {
         env.server = true;
     return env;
 }
-function isConfigSet(configValueSources, configName) {
-    const source = getConfigValueSource(configValueSources, configName);
-    return (!!source &&
-        !(source.valueIsLoaded &&
-            // Enable users to suppress inherited config by overriding it with `null`
-            source.value === null));
-}
-function getConfigValueSource(configValueSources, configName) {
-    const sources = configValueSources[configName];
-    if (!sources)
-        return null;
-    const configValueSource = sources[0];
-    assert(configValueSource);
-    return configValueSource;
+function isConfigSet(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    return !!source;
 }

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/crawlPlusFiles.js

@@ -1,7 +1,7 @@
 export { crawlPlusFiles };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
-import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, } from '../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, getGlobalObject, } from '../../utils.js';
 import path from 'node:path';
 import { glob } from 'tinyglobby';
 import { exec } from 'node:child_process';
@@ -14,8 +14,9 @@ import { ignorePatternsBuiltIn } from './crawlPlusFiles/ignorePatternsBuiltIn.js
 const execA = promisify(exec);
 const debug = createDebugger('vike:crawl');
 assertIsNotProductionRuntime();
-assertIsSingleModuleInstance('getVikeConfig/crawlPlusFiles.ts');
-let gitIsNotUsable = false;
+const globalObject = getGlobalObject('getVikeConfig/crawlPlusFiles.ts', {
+    gitIsNotUsable: false,
+});
 async function crawlPlusFiles(userRootDir) {
     assertPosixPath(userRootDir);
     assertFilePathAbsoluteFilesystem(userRootDir);
@@ -48,7 +49,7 @@ async function crawlPlusFiles(userRootDir) {
 }
 // Same as tinyglobby() but using `$ git ls-files`
 async function gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers) {
-    if (gitIsNotUsable)
+    if (globalObject.gitIsNotUsable)
         return null;
     // Preserve UTF-8 file paths.
     // https://github.com/vikejs/vike/issues/1658
@@ -82,7 +83,7 @@ async function gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers) {
     }
     catch (err) {
         if (await isGitNotUsable(userRootDir)) {
-            gitIsNotUsable = true;
+            globalObject.gitIsNotUsable = true;
             return null;
         }
         throw err;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -8,6 +8,7 @@ export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 export type { VikeConfigInternal };
+export type { PageConfigBuildTimeBeforeComputed };
 export { getVikeConfig };
 export type { VikeConfig };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../types/PageConfig.js';
@@ -57,6 +58,7 @@ declare function getVikeConfigFromCliOrEnv(): {
     configFromCliOptions: import("../../cli/parseCli.js").CliOptions | null;
     configFromEnvVar: Record<string, unknown> | null;
 };
+type PageConfigBuildTimeBeforeComputed = Omit<PageConfigBuildTime, 'configValuesComputed'>;
 declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitionsInternal, configName: string): ConfigDefinitionInternal | null;
 declare function getConfVal(plusFile: PlusFile, configName: string): null | {
     value: unknown;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.js

@@ -10,7 +10,7 @@ export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 // Public usage
 export { getVikeConfig };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, assertIsSingleModuleInstance, genPromise, checkType, objectAssign, } from '../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, genPromise, checkType, objectAssign, getGlobalObject, } from '../utils.js';
 import { configDefinitionsBuiltIn, } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect, } from './resolveVikeConfigInternal/filesystemRouting.js';
 import { getViteDevServer } from '../../runtime/globalContext.js';
@@ -32,21 +32,19 @@ import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderCo
 import { getProxyForPublicUsage } from '../../../shared/getProxyForPublicUsage.js';
 import { setVikeConfigError } from '../../shared/getVikeConfigError.js';
 assertIsNotProductionRuntime();
-// We can simply use global variables since Vike's config is:
-//  - global
-//  - independent of Vite (therefore we don't need to tie Vike's config with Vite's `config` object)
-assertIsSingleModuleInstance('v1-design/getVikeConfig.ts');
-let restartVite = false;
-let vikeConfigHasBuildError = null;
-let isV1Design_ = null;
-let vikeConfigPromise = null;
-// TO-DO/next-major-release: remove
-let vikeConfigSync = null;
-let vikeConfigCtx = null; // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
-let prerenderContext;
+const globalObject = getGlobalObject('vite/shared/resolveVikeConfigInternal.ts', {
+    restartVite: false,
+    vikeConfigHasBuildError: null,
+    isV1Design_: null,
+    vikeConfigPromise: null,
+    // TO-DO/next-major-release: remove
+    vikeConfigSync: null,
+    vikeConfigCtx: null, // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
+    prerenderContext: null,
+});
 function reloadVikeConfig() {
-    assert(vikeConfigCtx);
-    const { userRootDir, vikeVitePluginOptions } = vikeConfigCtx;
+    assert(globalObject.vikeConfigCtx);
+    const { userRootDir, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
     assert(vikeVitePluginOptions);
     resolveVikeConfigInternal_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
 }
@@ -54,15 +52,15 @@ async function getVikeConfigInternal(
 // I don't remember the logic behind it — neither why we restart Vite's dev server, nor why we sometimes don't.
 // TO-DO/eventually: re-think all that. Some + settings are expected to influence Vite's config (restarting Vite's dev server is needed) while some don't.
 doNotRestartViteOnError = false) {
-    assert(vikeConfigCtx);
-    const { userRootDir, isDev, vikeVitePluginOptions } = vikeConfigCtx;
+    assert(globalObject.vikeConfigCtx);
+    const { userRootDir, isDev, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
     const vikeConfig = await getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     return vikeConfig;
 }
 // TO-DO/next-major-release: remove
 function getVikeConfigInternalSync() {
-    assert(vikeConfigSync);
-    return vikeConfigSync;
+    assert(globalObject.vikeConfigSync);
+    return globalObject.vikeConfigSync;
 }
 // TO-DO/eventually: this maybe(/probably?) isn't safe against race conditions upon file changes in development, thus:
 // - Like getGlobalContext() and getGlobalContextSync() — make getVikeConfig() async and provide a getVikeConfigSync() while discourage using it
@@ -83,29 +81,29 @@ config) {
 }
 function setVikeConfigContext(vikeConfigCtx_) {
     // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
-    vikeConfigCtx = vikeConfigCtx_;
+    globalObject.vikeConfigCtx = vikeConfigCtx_;
 }
 async function getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
-    if (!vikeConfigPromise) {
+    if (!globalObject.vikeConfigPromise) {
         resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     }
-    assert(vikeConfigPromise);
-    const vikeConfig = await vikeConfigPromise;
+    assert(globalObject.vikeConfigPromise);
+    const vikeConfig = await globalObject.vikeConfigPromise;
     return vikeConfig;
 }
 async function getVikeConfigInternalOptional() {
-    if (!vikeConfigPromise)
+    if (!globalObject.vikeConfigPromise)
         return null;
-    const vikeConfig = await vikeConfigPromise;
+    const vikeConfig = await globalObject.vikeConfigPromise;
     return vikeConfig;
 }
 function isV1Design() {
-    assert(typeof isV1Design_ === 'boolean');
-    return isV1Design_;
+    assert(typeof globalObject.isV1Design_ === 'boolean');
+    return globalObject.isV1Design_;
 }
 async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     const { promise, resolve, reject } = genPromise();
-    vikeConfigPromise = promise;
+    globalObject.vikeConfigPromise = promise;
     const esbuildCache = {
         transpileCache: {},
         vikeConfigDependencies: new Set(),
@@ -122,10 +120,10 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     }
     // There is a newer call — let the new call supersede the old one.
     // We deliberately swallow the intermetidate state (including any potential error) — it's now outdated and has existed only for a very short period of time.
-    if (vikeConfigPromise !== promise) {
+    if (globalObject.vikeConfigPromise !== promise) {
         // vikeConfigPromise.then(resolve).catch(reject)
         try {
-            resolve(await vikeConfigPromise);
+            resolve(await globalObject.vikeConfigPromise);
         }
         catch (err) {
             reject(err);
@@ -135,13 +133,13 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     if (!hasError) {
         assert(ret);
         assert(err === undefined);
-        const hadError = vikeConfigHasBuildError;
-        vikeConfigHasBuildError = false;
+        const hadError = globalObject.vikeConfigHasBuildError;
+        globalObject.vikeConfigHasBuildError = false;
         setVikeConfigError({ errorBuild: false });
         if (hadError) {
             logConfigErrorRecover();
-            if (restartVite) {
-                restartVite = false;
+            if (globalObject.restartVite) {
+                globalObject.restartVite = false;
                 restartViteDevServer();
             }
         }
@@ -150,10 +148,10 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     else {
         assert(ret === undefined);
         assert(err);
-        vikeConfigHasBuildError = true;
+        globalObject.vikeConfigHasBuildError = true;
         setVikeConfigError({ errorBuild: { err } });
         if (!doNotRestartViteOnError)
-            restartVite = true;
+            globalObject.restartVite = true;
         if (!isDev) {
             reject(err);
         }
@@ -167,8 +165,8 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
     const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
-    if (!isV1Design_)
-        isV1Design_ = pageConfigs.length > 0;
+    if (!globalObject.isV1Design_)
+        globalObject.isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
@@ -194,7 +192,7 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
         prerenderContext,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };
-    vikeConfigSync = vikeConfig;
+    globalObject.vikeConfigSync = vikeConfig;
     return vikeConfig;
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
@@ -1099,7 +1097,7 @@ function isGlobalLocation(locationId, plusFilesAll) {
 }
 function resolvePrerenderContext(vikeConfig) {
     const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
-    prerenderContext ?? (prerenderContext = {
+    globalObject.prerenderContext ?? (globalObject.prerenderContext = {
         isPrerenderingEnabled: false,
         isPrerenderingEnabledForAllPages: false,
         // Set at runPrerender()
@@ -1107,9 +1105,9 @@ function resolvePrerenderContext(vikeConfig) {
         // Set at runPrerender()
         pageContexts: null,
     });
-    prerenderContext.isPrerenderingEnabled = isPrerenderingEnabled;
-    prerenderContext.isPrerenderingEnabledForAllPages = isPrerenderingEnabledForAllPages;
-    return prerenderContext;
+    globalObject.prerenderContext.isPrerenderingEnabled = isPrerenderingEnabled;
+    globalObject.prerenderContext.isPrerenderingEnabledForAllPages = isPrerenderingEnabledForAllPages;
+    return globalObject.prerenderContext;
 }
 function restartViteDevServer() {
     const viteDevServer = getViteDevServer();
@@ -1146,7 +1144,7 @@ function getVikeConfigDummy(esbuildCache) {
         prerenderContext: prerenderContextDummy,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };
-    vikeConfigSync = vikeConfigDummy;
-    isV1Design_ = true;
+    globalObject.vikeConfigSync = vikeConfigDummy;
+    globalObject.isV1Design_ = true;
     return vikeConfigDummy;
 }

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

@@ -0,0 +1,4 @@
+export type VikeGlobalInternal = undefined | {
+    globals?: Record<string, Record<string, unknown> | true>;
+    fullyRenderedUrl?: string;
+};

package/dist/esm/types/VikeGlobalInternal.js

@@ -0,0 +1 @@
+export {};

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.237-commit-8749e81";
+export declare const PROJECT_VERSION: "0.4.237-commit-92dc549";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.237-commit-8749e81';
+export const PROJECT_VERSION = '0.4.237-commit-92dc549';

package/dist/esm/utils/assertVersion.js

@@ -1,6 +1,8 @@
 export { assertVersion };
 export { isVersionOrAbove };
 import { assert, assertUsage } from './assert.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
 function assertVersion(dependencyName, versionActual, versionExpected) {
     assert(versionActual);
     assert(versionExpected);

package/dist/esm/utils/debug.js

@@ -1,16 +1,16 @@
 export { createDebugger };
 export { isDebugActivated };
-import { isBrowser } from './isBrowser.js';
 import { isCallable } from './isCallable.js';
 import { objectAssign } from './objectAssign.js';
 import { assert, assertUsage } from './assert.js';
 import { checkType } from './checkType.js';
-import { getTerminalWidth } from './getTerminWidth.js';
+import { getTerminalWidth } from './getTerminalWidth.js';
 import pc from '@brillout/picocolors';
 import { isArray } from './isArray.js';
 import { isObject } from './isObject.js';
 import { setCreateDebugger } from '../shared/route/debug.js';
-assert(!isBrowser());
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
 setCreateDebugger(createDebugger); // for isomorphic code
 const flags = [
     'vike:crawl',

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

@@ -1,7 +1,8 @@
 export { getGlobalObject };
-export { assertIsSingleModuleInstance };
-type Key = `${string}.ts`;
+import type { VikeGlobalInternal } from '../types/VikeGlobalInternal.js';
+type ModuleId = `${string}.ts`;
 /** Share information across module instances. */
-declare function getGlobalObject<T extends Record<string, unknown> = never>(key: Key, defaultValue: T): T;
-/** Assert that the module is instantiated only once. */
-declare function assertIsSingleModuleInstance(key: Key): void;
+declare function getGlobalObject<T extends Record<string, unknown> = never>(moduleId: ModuleId, defaultValue: T): T;
+declare global {
+    var _vike: VikeGlobalInternal;
+}

package/dist/esm/utils/getGlobalObject.js

@@ -1,20 +1,13 @@
 export { getGlobalObject };
-export { assertIsSingleModuleInstance };
-import { assert } from './assert.js';
 /** Share information across module instances. */
-function getGlobalObject(key, defaultValue) {
-    const globalObjects = getGlobalObjects();
-    const globalObject = (globalObjects[key] = globalObjects[key] || defaultValue);
+function getGlobalObject(moduleId, defaultValue) {
+    const globals = getGlobals();
+    const globalObject = (globals[moduleId] ?? (globals[moduleId] = defaultValue));
     return globalObject;
 }
-/** Assert that the module is instantiated only once. */
-function assertIsSingleModuleInstance(key) {
-    const globalObjects = getGlobalObjects();
-    assert(!(key in globalObjects));
-}
-function getGlobalObjects() {
-    const projectKey = '_vike';
-    // @ts-ignore
-    const globalObjects = (globalThis[projectKey] = globalThis[projectKey] || {});
-    return globalObjects;
+function getGlobals() {
+    var _a;
+    globalThis._vike ?? (globalThis._vike = {});
+    (_a = globalThis._vike).globals ?? (_a.globals = {});
+    return globalThis._vike.globals;
 }

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

@@ -1,8 +1,8 @@
 export { isScriptFile };
 export { isPlainScriptFile };
 export { isTemplateFile };
-export { scriptFileExtensionPattern };
 export { scriptFileExtensionList };
+export { scriptFileExtensionPattern };
 declare const scriptFileExtensionList: readonly ["js", "cjs", "mjs", "ts", "cts", "mts", "jsx", "cjsx", "mjsx", "tsx", "ctsx", "mtsx", "vue", "svelte", "marko", "md", "mdx"];
 declare const scriptFileExtensionPattern: string;
 declare function isScriptFile(filePath: string): boolean;