vike 0.4.222 → 0.4.223-commit-586dbfb

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -37,26 +37,29 @@ function getUrlParsed(pageContext) {
     //  6. The value of pageContext.urlPathname is now '/login': the pathname of `pageContext.urlLogical`. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
     // Reproduction: https://github.com/vikejs/vike/discussions/1436#discussioncomment-8142023
     // Determine logical URL
-    // TODO/soon: revert https://github.com/vikejs/vike/issues/2138#issuecomment-2631713411
-    const assertUrlResolved = (src) => assert(urlResolved && typeof urlResolved === 'string', { src, urlResolved });
+    const assertUrlResolved = (src) => assert(typeof urlResolved === 'string', 
+    // TODO/eventually: remove debug logs, see:
+    // - https://github.com/vikejs/vike/issues/2138#issuecomment-2631713411
+    // - https://github.com/vikejs/vike/commit/5c7810f3080ab62536950f26e019bb2a3a517082
+    { src, urlResolved });
     let urlResolved;
-    let baseToBeRemoved;
+    let isBaseToBeRemoved;
     if (pageContext.urlLogical) {
         // Set by onBeforeRoute()
         urlResolved = pageContext.urlLogical;
-        baseToBeRemoved = false;
+        isBaseToBeRemoved = false;
         assertUrlResolved(1);
     }
     else if (pageContext._urlRewrite) {
         // Set by `throw render()`
         urlResolved = pageContext._urlRewrite;
-        baseToBeRemoved = false;
+        isBaseToBeRemoved = false;
         assertUrlResolved(2);
     }
     else {
         // Set by renderPage()
         urlResolved = pageContext.urlOriginal;
-        baseToBeRemoved = true;
+        isBaseToBeRemoved = true;
         assertUrlResolved(3);
     }
     assertUrlResolved(4);
@@ -69,7 +72,7 @@ function getUrlParsed(pageContext) {
     // - We assume there isn't any Base URL to the URLs set by the user at `throw render()` and onBeforeRoute()
     //   - This makes sense because the Base URL is merely a setting: ideally the user should write code that doesn't know anything about it (so that the user can remove/add/change Base URL without having to modify any code).
     // - pageContext.urlOriginal is the URL of the HTTP request and thus contains the Base URL.
-    const baseServer = !baseToBeRemoved ? '/' : pageContext._baseServer;
+    const baseServer = !isBaseToBeRemoved ? '/' : pageContext._baseServer;
     // Parse URL
     return parseUrl(urlResolved, baseServer);
 }
@@ -86,8 +89,8 @@ function urlGetter() {
 }
 function urlParsedGetter() {
     const { 
-    // remove hasBaseServer as it isn't part of UrlPublic
-    hasBaseServer: _, ...urlParsed } = getUrlParsed(this);
+    // remove isBaseMissing as it isn't part of UrlPublic
+    isBaseMissing: _, ...urlParsed } = getUrlParsed(this);
     const hashIsAvailable = isBrowser();
     const warnHashNotAvailable = (prop) => {
         assertWarning(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash)`, { onlyOnce: true, showStackTrace: true });

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

@@ -1,4 +1,4 @@
 export type { PageFile } from './getPageFiles/getPageFileObject.js';
-export type { ExportsAll, PageConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
+export type { ExportsAll, PageConfigUserFriendlyOld } from './page-configs/getPageConfigUserFriendly.js';
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';

package/dist/esm/shared/hooks/getHook.d.ts

@@ -9,7 +9,7 @@ export type { HookLoc };
 export type { HookTimeout };
 export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
-import type { PageConfigUserFriendly } from '../getPageFiles.js';
+import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
 import type { HookName, HookNamePage, HookNameGlobal } from '../page-configs/Config.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
 type Hook = HookLoc & {
@@ -26,10 +26,10 @@ type HookTimeout = {
     warning: number | false;
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
-declare function getHook(pageContext: PageConfigUserFriendly, hookName: HookName): null | Hook;
+declare function getHook(pageContext: PageConfigUserFriendlyOld, hookName: HookName): null | Hook;
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
-declare function assertHook<TPageContext extends PageConfigUserFriendly, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
+declare function assertHook<TPageContext extends PageConfigUserFriendlyOld, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
     exports: Record<THookName, Function | undefined>;
 };
 declare function getHookTimeoutDefault(hookName: HookName): HookTimeout;

package/dist/esm/shared/hooks/getHook.js

@@ -11,7 +11,7 @@ import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
 import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
-const globalObject = getGlobalObject('getHook.ts', {});
+const globalObject = getGlobalObject('hooks/getHook.ts', {});
 function getHook(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;

package/dist/esm/shared/page-configs/Config.d.ts

@@ -32,6 +32,7 @@ export type { OnRenderHtmlAsync };
 export type { OnRenderHtmlSync };
 export type { RouteAsync };
 export type { RouteSync };
+export type { Route };
 export type { KeepScrollPosition };
 import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-routing-runtime/prefetch/PrefetchSetting.js';
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
@@ -223,6 +224,7 @@ type RouteSync = (pageContext: PageContextServer | PageContextClient) => {
     routeParams?: Record<string, string>;
     precedence?: number;
 } | boolean;
+type Route = string | RouteSync | RouteAsync;
 /** Whether the page scrolls to the top upon navigation.
  *
  * https://vike.dev/keepScrollPosition
@@ -239,7 +241,7 @@ type ConfigBuiltIn = {
      *
      *  https://vike.dev/route
      */
-    route?: string | RouteAsync | RouteSync | ImportString;
+    route?: Route | ImportString;
     /** Protect page(s), e.g. forbid unauthorized access.
      *
      *  https://vike.dev/guard

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -1,6 +1,8 @@
 export type { PageConfigRuntime };
 export type { PageConfigRuntimeLoaded };
 export type { PageConfigBuildTime };
+export type { PageConfigCommon };
+export type { PageConfigRoute };
 export type { ConfigEnv };
 export type { ConfigEnvInternal };
 export type { PageConfigGlobalRuntime };
@@ -23,8 +25,13 @@ import type { ConfigDefinitions } from '../../node/plugin/plugins/importUserCode
 import type { PlusFile, PlusFilesByLocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/getPlusFilesAll.js';
 type PageConfigCommon = {
     pageId: string;
-    isErrorPage?: true;
-    routeFilesystem?: {
+} & PageConfigRoute;
+type PageConfigRoute = {
+    isErrorPage: true;
+    routeFilesystem?: undefined;
+} | {
+    isErrorPage?: undefined;
+    routeFilesystem: {
         routeString: string;
         definedBy: string;
     };
@@ -87,10 +94,11 @@ type ConfigValueSource = {
     locationId: LocationId;
     isOverriden: boolean;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
-    valueIsImportedAtRuntime: boolean;
+    valueIsLoadedWithImport: boolean;
     /** Whether the config value is a file path, for example config.client */
     valueIsFilePath?: true;
-    valueIsDefinedByPlusFile: boolean;
+    /** Whether the config value is defined by a +{configName}.js file */
+    valueIsDefinedByPlusValueFile: boolean;
 } & ({
     valueIsLoaded: false;
 } | {

package/dist/esm/shared/page-configs/getPageConfigUserFriendly.d.ts

@@ -1,8 +1,9 @@
-export { getPageConfigUserFriendlyOld };
-export { getPageConfigUserFriendlyNew };
-export type { ConfigUserFriendly };
-export type { PageConfigUserFriendly };
+export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendly_oldDesign };
+export { getPageConfigGlobalUserFriendly };
 export type { PageConfigsUserFriendly };
+export type { PageConfigUserFriendly };
+export type { PageConfigUserFriendlyOld };
 export type { Source };
 export type { Sources };
 export type { From };
@@ -10,9 +11,10 @@ export type { ExportsAll };
 export type { ConfigEntries };
 import type { FileType } from '../getPageFiles/fileTypes.js';
 import type { PageFile } from '../getPageFiles/getPageFileObject.js';
-import type { ConfigValues, PageConfigGlobalRuntime, PageConfigRuntimeLoaded } from './PageConfig.js';
+import type { ConfigValues, PageConfigBuildTime, PageConfigGlobalRuntime, PageConfigRuntime, PageConfigRuntimeLoaded } from './PageConfig.js';
 import { type ConfigDefinedAtOptional } from './getConfigDefinedAt.js';
 import type { ConfigResolved } from './Config/PageContextConfig.js';
+import type { Route } from './Config.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
     exportSource: string;
@@ -33,7 +35,7 @@ type ConfigEntries = Record<string, {
     configDefinedAt: ConfigDefinedAtOptional;
     configDefinedByFile: string | null;
 }[]>;
-type PageConfigUserFriendly = {
+type PageConfigUserFriendlyOld = {
     config: ConfigResolved;
     source: Source;
     sources: Sources;
@@ -74,18 +76,24 @@ type SourceConfigsComputed = {
     type: 'configsComputed';
     value: unknown;
 };
-type PageConfigsUserFriendly = Record<string, // pageId
-// pageId
-ConfigUserFriendly & {
-    route: string | null;
-}>;
-type ConfigUserFriendly = {
+type PageConfigUserFriendly = {
     config: ConfigResolved;
     _source: Source;
     _sources: Sources;
     _from: From;
 };
-declare function getPageConfigUserFriendlyNew(pageConfig: {
-    configValues: ConfigValues;
-}): ConfigUserFriendly;
-declare function getPageConfigUserFriendlyOld(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null, pageConfigGlobal: PageConfigGlobalRuntime): PageConfigUserFriendly;
+type PageConfigsUserFriendly = Record<string, // pageId
+PageConfigUserFriendlyWithRoute>;
+type WithRoute = {
+    route: Route;
+    isErrorPage?: undefined;
+} | {
+    route?: undefined;
+    isErrorPage: true;
+};
+type PageConfigUserFriendlyWithRoute = PageConfigUserFriendly & WithRoute;
+declare function getPageConfigUserFriendly(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, PageConfigUserFriendlyWithRoute];
+declare function getPageConfigGlobalUserFriendly({ pageConfigGlobalValues }: {
+    pageConfigGlobalValues: ConfigValues;
+}): PageConfigUserFriendly;
+declare function getPageConfigUserFriendly_oldDesign(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null, pageConfigGlobal: PageConfigGlobalRuntime): PageConfigUserFriendlyOld;

package/dist/esm/shared/page-configs/getPageConfigUserFriendly.js

@@ -1,20 +1,51 @@
-export { getPageConfigUserFriendlyOld };
-export { getPageConfigUserFriendlyNew };
+export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendly_oldDesign };
+export { getPageConfigGlobalUserFriendly };
 import { assertDefaultExports, forbiddenDefaultExports } from '../getPageFiles/assert_exports_old_design.js';
 import { getConfigDefinedAtOptional, getDefinedAtString } from './getConfigDefinedAt.js';
 import { getConfigValueFilePathToShowToUser } from './helpers.js';
 import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser, isScriptFile, isTemplateFile } from '../utils.js';
 import pc from '@brillout/picocolors';
-function getPageConfigUserFriendlyNew(pageConfig) {
-    const res = getPageConfigUserFriendlyV1Desin(pageConfig);
+function getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfigValues) {
+    const pageConfigUserFriendly = getPageConfigUserFriendly_public({ pageConfigGlobalValues, pageConfigValues });
+    let page;
+    if (!pageConfig.isErrorPage) {
+        const route = pageConfigUserFriendly.config.route ?? pageConfig.routeFilesystem.routeString;
+        page = {
+            ...pageConfigUserFriendly,
+            route
+        };
+    }
+    else {
+        page = {
+            ...pageConfigUserFriendly,
+            isErrorPage: true
+        };
+    }
+    return [pageConfig.pageId, page];
+}
+function getPageConfigUserFriendly_public({ pageConfigGlobalValues, pageConfigValues }) {
+    const pageConfigUserFriendly = getPageConfigUserFriendly_base({ pageConfigGlobalValues, pageConfigValues });
+    return getPublicCopy(pageConfigUserFriendly);
+}
+function getPublicCopy(pageConfigUserFriendly) {
+    const p = pageConfigUserFriendly;
     return {
-        config: res.config,
-        _source: res.source,
-        _sources: res.sources,
-        _from: res.from
+        config: p.config,
+        _source: p.source,
+        _sources: p.sources,
+        _from: p.from
     };
 }
-function getPageConfigUserFriendlyOld(pageFiles, pageConfig, pageConfigGlobal) {
+function getPageConfigUserFriendly_base({ pageConfigGlobalValues, pageConfigValues }) {
+    const configValues = { ...pageConfigGlobalValues, ...pageConfigValues };
+    return getPageConfigUserFriendly_V1Design({ configValues });
+}
+function getPageConfigGlobalUserFriendly({ pageConfigGlobalValues }) {
+    const pageConfigGlobalUserFriendly = getPageConfigUserFriendly_V1Design({ configValues: pageConfigGlobalValues });
+    return getPublicCopy(pageConfigGlobalUserFriendly);
+}
+function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGlobal) {
     const config = {};
     const configEntries = {}; // TODO/v1-release: remove
     const exportsAll = {}; // TODO/v1-release: remove
@@ -39,8 +70,9 @@ function getPageConfigUserFriendlyOld(pageFiles, pageConfig, pageConfigGlobal) {
     let sources;
     let from;
     if (pageConfig) {
-        const res = getPageConfigUserFriendlyV1Desin({
-            configValues: { ...pageConfigGlobal.configValues, ...pageConfig.configValues }
+        const res = getPageConfigUserFriendly_base({
+            pageConfigGlobalValues: pageConfigGlobal.configValues,
+            pageConfigValues: pageConfig.configValues
         });
         source = res.source;
         sources = res.sources;
@@ -87,7 +119,7 @@ function getPageConfigUserFriendlyOld(pageFiles, pageConfig, pageConfigGlobal) {
     return pageContextExports;
 }
 // V1 design
-function getPageConfigUserFriendlyV1Desin(pageConfig) {
+function getPageConfigUserFriendly_V1Design(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};

package/dist/esm/shared/page-configs/serialize/PageConfigSerialized.d.ts

@@ -2,11 +2,12 @@ export type { PageConfigRuntimeSerialized };
 export type { PageConfigGlobalRuntimeSerialized };
 export type { ConfigValueSerialized };
 export type { ValueSerialized };
-import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, PageConfigRuntime } from '../PageConfig.js';
+import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, PageConfigCommon, PageConfigRuntime } from '../PageConfig.js';
 /** Page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
-type PageConfigRuntimeSerialized = Omit<PageConfigRuntime, 'configValues'> & {
+type PageConfigRuntimeSerialized = PageConfigCommon & {
     /** Config values that are serializable and loaded eagerly such as config.passToClient */
     configValuesSerialized: Record<string, ConfigValueSerialized>;
+    loadConfigValuesAll: PageConfigRuntime['loadConfigValuesAll'];
 };
 type PageConfigGlobalRuntimeSerialized = {
     configValuesSerialized: Record<string, ConfigValueSerialized>;

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

@@ -12,15 +12,9 @@ function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     // pageConfigs
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = parseConfigValuesSerialized(pageConfigSerialized.configValuesSerialized);
-        const { pageId, isErrorPage, routeFilesystem, loadConfigValuesAll } = pageConfigSerialized;
         assertRouteConfigValue(configValues);
-        return {
-            pageId,
-            isErrorPage,
-            routeFilesystem,
-            configValues,
-            loadConfigValuesAll
-        };
+        const pageConfig = { ...pageConfigSerialized, configValues };
+        return pageConfig;
     });
     // pageConfigsGlobal
     const pageConfigGlobal = { configValues: {} };

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.d.ts

@@ -1,8 +1,10 @@
 export { serializeConfigValues };
 export { getConfigValuesBase };
+export { isJsonValue };
 export type { FilesEnv };
 import type { ConfigEnvInternal, ConfigValueSource, DefinedAtFile, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
 declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], filesEnv: FilesEnv, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
+declare function isJsonValue(value: unknown): boolean;
 declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, isEager: boolean | null): ConfigValuesBase;
 type ConfigValuesBase = ({
     configValueBase: {

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

@@ -1,11 +1,13 @@
 export { serializeConfigValues };
 export { getConfigValuesBase };
+export { isJsonValue };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { assert, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js';
 import { getConfigValueFilePathToShowToUser } from '../helpers.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import pc from '@brillout/picocolors';
+const stringifyOptions = { forbidReactElements: true };
 const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
 const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 // This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigs()
@@ -44,7 +46,7 @@ function serializeConfigValues(pageConfig, importStatements, filesEnv, isEnvMatc
 function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
     assert(configValueSource.isOverriden === false);
     let valueData;
-    if ('value' in configValueSource) {
+    if ('value' in configValueSource && !configValueSource.valueIsLoadedWithImport) {
         valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements, filesEnv, configValueSource.configEnv);
     }
     else {
@@ -96,14 +98,13 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
 }
 function getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName) {
     assert(!configValueSource.valueIsFilePath);
-    const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath, configEnv } = configValueSource;
-    assert(valueIsImportedAtRuntime);
+    const { valueIsDefinedByPlusValueFile, definedAtFilePath, configEnv } = configValueSource;
     const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
-    if (valueIsDefinedByPlusFile)
+    if (valueIsDefinedByPlusValueFile)
         assert(fileExportName === undefined);
     const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*', filesEnv, configEnv, configName);
     return {
-        type: valueIsDefinedByPlusFile ? 'plus-file' : 'pointer-import',
+        type: valueIsDefinedByPlusValueFile ? 'plus-file' : 'pointer-import',
         valueAsJsCode: importName
     };
 }
@@ -120,7 +121,7 @@ function valueToJson(value, configName, definedAtData, importStatements, filesEn
     try {
         configValueSerialized = stringify(value, {
             valueName,
-            forbidReactElements: true,
+            ...stringifyOptions,
             // Replace import strings with import variables.
             // - We don't need this anymore and could remove it.
             //   - We temporarily needed it for nested document configs (`config.document.{title,description,favicon}`), but we finally decided to go for flat document configs instead (`config.{title,description,favicon}`).
@@ -147,6 +148,15 @@ function valueToJson(value, configName, definedAtData, importStatements, filesEn
     assert(!configValueSerialized.includes(REPLACE_ME_AFTER));
     return configValueSerialized;
 }
+function isJsonValue(value) {
+    try {
+        stringify(value, stringifyOptions);
+    }
+    catch (err) {
+        return false;
+    }
+    return true;
+}
 function logJsonSerializeError(err, configName, definedAtData) {
     /*
     // import { isJsonSerializerError } from '@brillout/json-serializer/stringify'

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

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

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

@@ -8,7 +8,7 @@ import { getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
 import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/getHook.js';
 async function loadPageRoutes(
-// Remove all arguments and use GlobalContext instead?
+// Remove all arguments and use GlobalContextInternal instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
     // TODO/next-major: remove & make this function sync
     await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));

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

@@ -131,6 +131,12 @@ type PageContextBuiltInCommon<Data> = {
     url: string;
     /** @deprecated */
     pageExports: Record<string, unknown>;
+    /**
+     * Whether the Base URL is missing in the URL of the HTTP request made to the SSR server.
+     *
+     * https://vike.dev/base-url#setup
+     */
+    isBaseMissing?: true;
 };
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer;
 type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'pageId' | 'source' | 'sources' | 'from'> & {

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.222";
+export declare const PROJECT_VERSION: "0.4.223-commit-586dbfb";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.222';
+export const PROJECT_VERSION = '0.4.223-commit-586dbfb';

package/dist/esm/utils/assert.js

@@ -42,7 +42,7 @@ function assert(condition, debugInfo) {
         const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
         return pc.dim(`Debug info (for Vike maintainers; you can ignore this): ${debugInfoSerialized}`);
     })();
-    const link = pc.blue('https://github.com/vikejs/vike/issues/new');
+    const link = pc.blue('https://github.com/vikejs/vike/issues/new?template=bug.yml');
     let errMsg = [
         `You stumbled upon a Vike bug. Go to ${link} and copy-paste this error. A maintainer will fix the bug (usually within 24 hours).`,
         debugStr

package/dist/esm/utils/assertSetup.js

@@ -16,7 +16,7 @@ import { isVitest } from './isVitest.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser();
 const debug = createDebugger('vike:setup');
-const setup = getGlobalObject('utils/assertIsNotProductionRuntime.ts', {});
+const setup = getGlobalObject('utils/assertSetup.ts', {});
 // Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
 function assertIsNotProductionRuntime() {
     if (debug.isActivated)

package/dist/esm/utils/assertSingleInstance.js

@@ -11,7 +11,7 @@ import pc from '@brillout/picocolors';
 /* Use original assertUsage() & assertWarning() after all CJS is removed from node_modules/vike/dist/
 import { assertUsage, assertWarning } from './assert.js'
 */
-const globalObject = getGlobalObject('assertSingleInstance.ts', {
+const globalObject = getGlobalObject('utils/assertSingleInstance.ts', {
     instances: [],
     alreadyLogged: new Set()
 });
@@ -22,7 +22,7 @@ function assertSingleInstance() {
         const versions = unique(globalObject.instances);
         assertUsage(versions.length <= 1, 
         // DO *NOT* patch vike to remove this error: because of multiple conflicting versions, you *will* eventually encounter insidious issues that hard to debug and potentially a security hazard, see for example https://github.com/vikejs/vike/issues/1108
-        `vike@${pc.bold(versions[0])} and vike@${pc.bold(versions[1])} loaded but only one version should be loaded`);
+        `vike@${pc.bold(versions[0])} and vike@${pc.bold(versions[1])} loaded but it's forbidden to load different versions`);
     }
     if (globalObject.checkSingleInstance && globalObject.instances.length > 1) {
         /*/ Not sure whether circular dependency can cause problems? In principle not since client-side code is ESM.

package/dist/esm/utils/findFile.js

@@ -3,7 +3,7 @@ import path from 'path';
 import fs from 'fs';
 import { isArray } from './isArray.js';
 import { assertPosixPath } from './path.js';
-// We need to be able to crawl the filesystem, regardless of Vike's `$ git ls-files` command call, because we need to fallback if the user didn't setup Git (e.g. we cannot remove the fast-glob fallback).
+// We need to be able to crawl the filesystem, regardless of Vike's `$ git ls-files` command call, because we need to fallback if the user didn't setup Git (e.g. we cannot remove the tinyglobby fallback).
 function findFile(arg, cwd) {
     assertPosixPath(cwd);
     const filenames = isArray(arg) ? arg : [arg];

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

@@ -1,6 +1,7 @@
 export { getGlobalObject };
 export { assertIsSingleModuleInstance };
+type Key = `${string}/${string}.ts`;
 /** Share information across module instances. */
-declare function getGlobalObject<T extends Record<string, unknown> = never>(key: `${string}.ts`, defaultValue: T): T;
+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: `${string}.ts`): void;
+declare function assertIsSingleModuleInstance(key: Key): void;

package/dist/esm/utils/getGlobalObject.js

@@ -2,17 +2,13 @@ export { getGlobalObject };
 export { assertIsSingleModuleInstance };
 import { assert } from './assert.js';
 /** 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.
-key, defaultValue) {
+function getGlobalObject(key, defaultValue) {
     const globalObjects = getGlobalObjects();
     const globalObject = (globalObjects[key] = globalObjects[key] || defaultValue);
     return globalObject;
 }
 /** Assert that the module is instantiated only once. */
-function assertIsSingleModuleInstance(
-// We use the filename (or file path) as key.
-key) {
+function assertIsSingleModuleInstance(key) {
     const globalObjects = getGlobalObjects();
     assert(!(key in globalObjects));
 }

package/dist/esm/utils/parseUrl-extras.js

@@ -28,8 +28,8 @@ function prependBase(url, baseServer) {
     return `${baseServerNormalized}${url}`;
 }
 function removeBaseServer(url, baseServer) {
-    const { hasBaseServer, origin, pathname, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, baseServer);
-    assert(hasBaseServer);
+    const { isBaseMissing, origin, pathname, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, baseServer);
+    assert(!isBaseMissing);
     assertUrlComponents(url, origin, pathnameOriginal, searchOriginal, hashOriginal);
     const urlWithoutBase = createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal);
     return urlWithoutBase;

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

@@ -10,7 +10,6 @@ export { isBaseServer };
 export { assertUrlComponents };
 export { createUrlFromComponents };
 export type { UrlPublic };
-export type { UrlPrivate };
 type UrlPublic = {
     /** The full URL. */
     href: string;
@@ -41,10 +40,10 @@ type UrlPublic = {
     /** @deprecated */
     searchString: null | string;
 };
-type UrlPrivate = Omit<UrlPublic, 'hashString' | 'searchString'> & {
-    hasBaseServer: boolean;
+type UrlInternal = Omit<UrlPublic, 'hashString' | 'searchString'> & {
+    isBaseMissing: boolean;
 };
-declare function parseUrl(url: string, baseServer: string): UrlPrivate;
+declare function parseUrl(url: string, baseServer: string): UrlInternal;
 declare function isBaseServer(baseServer: string): boolean;
 declare function assertUrlComponents(url: string, origin: string | null, pathnameOriginal: string, searchOriginal: string | null, hashOriginal: string | null): void;
 declare function createUrlFromComponents(origin: string | null, pathname: string, search: string | null, hash: string | null): string;

package/dist/esm/utils/parseUrl.js

@@ -45,7 +45,7 @@ function parseUrl(url, baseServer) {
     const pathnameOriginal = urlWithoutHashNorSearch.slice((origin || '').length);
     assertUrlComponents(url, origin, pathnameOriginal, searchOriginal, hashOriginal);
     // Base URL
-    let { pathname, hasBaseServer } = removeBaseServer(pathnameAbsoluteWithBase, baseServer);
+    let { pathname, isBaseMissing } = removeBaseServer(pathnameAbsoluteWithBase, baseServer);
     // pageContext.urlParsed.href
     const href = createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal);
     // pageContext.urlParsed.{hostname, port}
@@ -62,7 +62,7 @@ function parseUrl(url, baseServer) {
         origin,
         pathname,
         pathnameOriginal: pathnameOriginal,
-        hasBaseServer,
+        isBaseMissing,
         search,
         searchAll,
         searchOriginal,
@@ -231,7 +231,7 @@ function removeBaseServer(pathnameAbsoluteWithBase, baseServer) {
     assert(baseServer.startsWith('/'));
     if (baseServer === '/') {
         const pathname = pathnameAbsoluteWithBase;
-        return { pathname, hasBaseServer: true };
+        return { pathname, isBaseMissing: false };
     }
     // Support `url === '/some-base-url' && baseServer === '/some-base-url/'`
     let baseServerNormalized = baseServer;
@@ -241,7 +241,7 @@ function removeBaseServer(pathnameAbsoluteWithBase, baseServer) {
     }
     if (!urlPathname.startsWith(baseServerNormalized)) {
         const pathname = pathnameAbsoluteWithBase;
-        return { pathname, hasBaseServer: false };
+        return { pathname, isBaseMissing: true };
     }
     assert(urlPathname.startsWith('/') || urlPathname.startsWith('http'));
     assert(urlPathname.startsWith(baseServerNormalized));
@@ -249,7 +249,7 @@ function removeBaseServer(pathnameAbsoluteWithBase, baseServer) {
     if (!urlPathname.startsWith('/'))
         urlPathname = '/' + urlPathname;
     assert(urlPathname.startsWith('/'));
-    return { pathname: urlPathname, hasBaseServer: true };
+    return { pathname: urlPathname, isBaseMissing: false };
 }
 function isBaseServer(baseServer) {
     return baseServer.startsWith('/');