vike 0.4.267 → 0.4.268-commit-45c1759

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

@@ -4,6 +4,7 @@ export { getVikeConfig };
 export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { setVikeConfigContext };
+export { setViteEnvironmentNames };
 export { isVikeConfigContextSet };
 export { reloadVikeConfig };
 export { isV1Design };
@@ -12,7 +13,6 @@ export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 export { EARLY_SETTINGS };
 import { deepEqual } from '../../../utils/deepEqual.js';
-import { assertKeys } from '../../../utils/assertKeys.js';
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { getMostSimilar } from '../../../utils/getMostSimilar.js';
 import { objectEntries } from '../../../utils/objectEntries.js';
@@ -23,6 +23,7 @@ import { checkType } from '../../../utils/checkType.js';
 import { genPromise } from '../../../utils/genPromise.js';
 import { getGlobalObject } from '../../../utils/getGlobalObject.js';
 import { hasProp } from '../../../utils/hasProp.js';
+import { includes } from '../../../utils/includes.js';
 import { isCallable } from '../../../utils/isCallable.js';
 import { isObject } from '../../../utils/isObject.js';
 import { joinEnglish } from '../../../utils/joinEnglish.js';
@@ -42,6 +43,7 @@ import { loadPointerImport, loadValueFile } from './resolveVikeConfigInternal/lo
 import { resolvePointerImport } from './resolveVikeConfigInternal/resolvePointerImport.js';
 import { parsePointerImportData } from './resolveVikeConfigInternal/pointerImports.js';
 import { getFilePathResolved } from './getFilePath.js';
+import { isEnvironmentBuiltIn, isEnvironmentNameValid } from '../../../shared-server-node/vike-environments.js';
 import { getConfigValueBuildTime } from '../../../shared-server-client/page-configs/getConfigValueBuildTime.js';
 import { resolveGlobalConfigPublic, } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
 import { getConfigValuesBase, isJsonValue, } from '../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
@@ -65,12 +67,13 @@ const globalObject = getGlobalObject('vite/shared/resolveVikeConfigInternal.ts',
     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,
+    viteEnvironmentNames: null,
 });
 function reloadVikeConfig() {
     assert(globalObject.vikeConfigCtx);
-    const { userRootDir, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
+    const { userRootDir, isDev, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
     assert(vikeVitePluginOptions);
-    resolveVikeConfigInternal_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
+    resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions);
 }
 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.
@@ -110,6 +113,32 @@ function setVikeConfigContext(vikeConfigCtx_) {
     // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
     globalObject.vikeConfigCtx = vikeConfigCtx_;
 }
+// Vike's config is resolved before Vite's environments are known (Vike's config can modify Vite's config)
+async function setViteEnvironmentNames(viteEnvironmentNames) {
+    globalObject.viteEnvironmentNames = viteEnvironmentNames;
+    if (!globalObject.vikeConfigPromise)
+        return;
+    const vikeConfig = await globalObject.vikeConfigPromise;
+    // Resolve again: to report a missing environment like any other config error, or to recover from one (e.g. the user added the environment to Vite's config)
+    const isMissing = getAdditionalEnvironmentsMissing(vikeConfig._additionalEnvironmentNames).length > 0;
+    if (!isMissing && !globalObject.vikeConfigHasBuildError)
+        return;
+    reloadVikeConfig();
+    await globalObject.vikeConfigPromise;
+}
+function getAdditionalEnvironmentsMissing(additionalEnvironmentNames) {
+    const { viteEnvironmentNames } = globalObject;
+    if (!viteEnvironmentNames)
+        return [];
+    return additionalEnvironmentNames.filter((name) => !viteEnvironmentNames.includes(name));
+}
+function assertAdditionalEnvironmentsExist(additionalEnvironmentNames) {
+    const [name] = getAdditionalEnvironmentsMissing(additionalEnvironmentNames);
+    if (name === undefined)
+        return;
+    assert(globalObject.viteEnvironmentNames);
+    assertUsage(false, `The environment ${pc.cyan(JSON.stringify(name))} is used by ${pc.cyan('meta.env')} but it doesn't exist in Vite's ${pc.cyan('config.environments')} (${joinEnglish(globalObject.viteEnvironmentNames.map((n) => pc.cyan(n)), 'and')})`);
+}
 function isVikeConfigContextSet() {
     return !!globalObject.vikeConfigCtx;
 }
@@ -219,6 +248,8 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, vik
     const plusFilesByLocationId = await getPlusFiles(userRootDir, vikeTranspileCache);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesByLocationId, userRootDir, vikeTranspileCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesByLocationId, userRootDir);
+    const additionalEnvironmentNames = getAdditionalEnvironmentNames(getMetaEnvAll(configDefinitionsResolved, [pageConfigGlobal, ...pageConfigs]));
+    assertAdditionalEnvironmentsExist(additionalEnvironmentNames);
     if (!globalObject.isV1Design_)
         globalObject.isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
@@ -241,6 +272,7 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, vik
         _pageConfigGlobal: pageConfigGlobal,
         _vikeConfigDependencies: vikeTranspileCache.vikeConfigDependencies,
         _extensions,
+        _additionalEnvironmentNames: additionalEnvironmentNames,
     };
     globalObject.vikeConfigSync = vikeConfig;
     return vikeConfig;
@@ -330,6 +362,23 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesByLocationI
     assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal };
 }
+// Get all the `meta.env` of all configs
+function getMetaEnvAll(configDefinitionsResolved, pageConfigs) {
+    const configDefinitionsAll = [
+        configDefinitionsResolved.configDefinitionsGlobal,
+        ...Object.values(configDefinitionsResolved.configDefinitionsLocal).map(({ configDefinitions }) => configDefinitions),
+    ];
+    return [
+        ...configDefinitionsAll.flatMap((configDefinitions) => Object.values(configDefinitions).map(({ env }) => env)),
+        ...pageConfigs.flatMap(({ configValueSources }) => Object.values(configValueSources).flatMap((sources) => sources.map(({ configEnv }) => configEnv))),
+    ];
+}
+function getAdditionalEnvironmentNames(configEnvs) {
+    const names = configEnvs.flatMap((configEnv) => Object.entries(configEnv)
+        .filter(([, value]) => value)
+        .map(([name]) => name));
+    return unique(names.filter(isAdditionalEnvironmentName));
+}
 function resolvePageConfigBuildTime(pageId, locationId, plusFilesRelevant, configDefinitionsLocal, plusFilesByLocationId, userRootDir) {
     const configValueSources = {};
     objectEntries(configDefinitionsLocal)
@@ -482,7 +531,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
 function getConfigValues(pageConfig, isGlobalConfig) {
     const tolerateMissingValue = !isGlobalConfig;
     const configValues = {};
-    getConfigValuesBase(pageConfig, { isForConfig: true }, null).forEach((entry) => {
+    getConfigValuesBase(pageConfig, { isConfigEnvironment: true }, null).forEach((entry) => {
         if (entry.configValueBase.type === 'computed') {
             assert('value' in entry); // Help TS
             const { configValueBase, value, configName } = entry;
@@ -1091,11 +1140,13 @@ function applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEf
     });
 }
 function getComputed(pageConfig) {
+    assert(globalObject.vikeConfigCtx);
+    const { isDev } = globalObject.vikeConfigCtx;
     const configValuesComputed = {};
     objectEntries(pageConfig.configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef._computed)
             return;
-        const value = configDef._computed(pageConfig);
+        const value = configDef._computed(pageConfig, isDev);
         if (value === undefined)
             return;
         configValuesComputed[configName] = {
@@ -1220,6 +1271,14 @@ function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
+// Keys of `meta.env` that only Vike sets
+const configEnvKeysInternal = ['clientRoutingOnly', 'eager'];
+// Keys of `meta.env` that can't be environment names
+// - Including file suffixes such as `.ssr.js`, `.shared.js`, `.clear.js`, `.default.js`
+const configEnvKeysReserved = ['ssr', 'shared', 'clear', 'default', ...configEnvKeysInternal];
+function isAdditionalEnvironmentName(configEnvKey) {
+    return (!isEnvironmentBuiltIn(configEnvKey) && !['config', 'production', ...configEnvKeysInternal].includes(configEnvKey));
+}
 function getConfigEnvValue(val, errMsgIntro) {
     const errInvalidValue = `${errMsgIntro} an invalid value ${pc.cyan(JSON.stringify(val))}`;
     // Legacy outdated values
@@ -1235,22 +1294,23 @@ function getConfigEnvValue(val, errMsgIntro) {
             if (val === 'config-only')
                 return { config: true };
             if (val === '_routing-lazy')
-                return { server: true, client: 'if-client-routing' };
+                return { server: true, client: true, clientRoutingOnly: true };
             if (val === '_routing-eager')
-                return { server: true, client: 'if-client-routing', eager: true };
+                return { server: true, client: true, clientRoutingOnly: true, eager: true };
             assertUsage(false, errInvalidValue);
         })();
         assertWarning(false, `${errMsgIntro} ${pc.cyan(val)} which is deprecated and will be removed in the next major release`, { onlyOnce: true });
         return valConverted;
     }
     assertUsage(isObject(val), `${errMsgIntro} an invalid type ${pc.cyan(typeof val)}`);
-    assertKeys(val, ['config', 'server', 'client'], `${errInvalidValue}:`);
-    assertUsage(hasProp(val, 'config', 'undefined') || hasProp(val, 'config', 'boolean'), errInvalidValue);
-    assertUsage(hasProp(val, 'server', 'undefined') || hasProp(val, 'server', 'boolean'), errInvalidValue);
-    assertUsage(hasProp(val, 'client', 'undefined') || hasProp(val, 'client', 'boolean'), errInvalidValue);
+    Object.entries(val).forEach(([key, value]) => {
+        assertUsage(!includes(configEnvKeysReserved, key), `${errInvalidValue}: ${pc.cyan(key)} can't be an environment name, because ${includes(configEnvKeysInternal, key) ? 'Vike uses it internally' : `it's a file suffix (${pc.cyan(`+Page.${key}.js`)})`}`);
+        assertUsage(isEnvironmentNameValid(key), `${errInvalidValue}: ${pc.cyan(key)} isn't a valid environment name`);
+        assertUsage(value === undefined || typeof value === 'boolean', errInvalidValue);
+    });
     /* To allow users to set an eager config:
      * - Uncomment line below.
-     * - Add 'eager' to assertKeys() call above.
+     * - Move 'eager' from configEnvKeysInternal to the keys that isAdditionalEnvironmentName() excludes.
      * - Add `eager: boolean` to ConfigEnv type.
     assertUsage(hasProp(val, 'eager', 'undefined') || hasProp(val, 'eager', 'boolean'), errInvalidValue)
     */
@@ -1279,11 +1339,21 @@ function resolveConfigEnv(configEnv, filePath) {
         else if (suffixes.includes('client')) {
             configEnvResolved.client = true;
             configEnvResolved.server = false;
+            // Additional environments (e.g. `rsc`) are server-side
+            Object.keys(configEnvResolved).forEach((key) => {
+                if (isAdditionalEnvironmentName(key))
+                    delete configEnvResolved[key];
+            });
         }
         else if (suffixes.includes('shared')) {
             configEnvResolved.server = true;
             configEnvResolved.client = true;
         }
+        else {
+            return configEnvResolved;
+        }
+        // The file suffix decides, regardless of Client Routing
+        delete configEnvResolved.clientRoutingOnly;
     }
     return configEnvResolved;
 }
@@ -1312,7 +1382,9 @@ async function resolvePrerenderContext(vikeConfig) {
 }
 function restartViteDevServer() {
     const viteDevServer = getViteDevServer();
-    assert(viteDevServer);
+    // setViteEnvironmentNames() can reload Vike's config while Vite resolves its config, before the dev server exists
+    if (!viteDevServer)
+        return;
     swallowViteLogForceOptimization_enable();
     (async () => {
         try {
@@ -1347,6 +1419,7 @@ async function getVikeConfigDummy(vikeTranspileCache) {
         prerenderContext: prerenderContextDummy,
         _vikeConfigDependencies: vikeTranspileCache.vikeConfigDependencies,
         _extensions: [],
+        _additionalEnvironmentNames: [],
     };
     globalObject.vikeConfigSync = vikeConfigDummy;
     globalObject.isV1Design_ = true;

package/dist/server/__internal/fetch-deprecated.d.ts

@@ -0,0 +1,2 @@
+export { default } from './fetch.js';
+import '../assertEnvServer.js';

package/dist/server/__internal/fetch-deprecated.js

@@ -0,0 +1,6 @@
+export { default } from './fetch.js';
+// TO-DO/next-major-release: remove this export (the entire file)
+import { assertWarning } from '../../utils/assert.js';
+import pc from '@brillout/picocolors';
+import '../assertEnvServer.js';
+assertWarning(false, `${pc.cyan("import vike from 'vike/fetch'")} is deprecated, see ${pc.underline('https://vike.dev/migration/vike-fetch')}`, { onlyOnce: true });

package/dist/server/__internal/fetch.d.ts

@@ -0,0 +1,9 @@
+import '../assertEnvServer.js';
+declare const _default: {
+    fetch: ((request: Request, context?: Universal.Context, runtime?: import("@universal-middleware/core").RuntimeAdapterTarget<unknown>) => Promise<Response>) & import("@universal-middleware/core").WithUniversalSymbols<{
+        readonly name: 'vike';
+        readonly method: ["GET", "POST", "PUT", "PATCH", "HEAD", "OPTIONS"];
+        readonly path: '/**';
+    }>;
+};
+export default _default;

package/dist/server/__internal/fetch.js

@@ -0,0 +1,5 @@
+import '../assertEnvServer.js';
+import { vikeUniversalMiddleware } from '../runtime/universal-middleware/vikeUniversalMiddleware.js';
+export default {
+    fetch: vikeUniversalMiddleware,
+};

package/dist/server/__internal/index.d.ts

@@ -1,9 +1,12 @@
 export { setGlobalContext_prodBuildEntry } from '../runtime/globalContext.js';
+export { getMiddlewaresPipe_nonHandlers, getMiddlewaresPipe_handlers, } from '../runtime/universal-middleware/getMiddlewaresPipe.js';
+export { getPageContextJson };
 export { route, getPagesAndRoutes };
 export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
 import { route as routeInternal, type PageRoutes } from '../../shared-server-client/route/index.js';
 import type { PageFile } from '../../shared-server-client/getPageFiles/getPageFileObject.js';
 import { PageConfigRuntime } from '../../types/PageConfig.js';
+import type { PageContextServer } from '../../types/PageContext.js';
 import '../assertEnvServer.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
@@ -19,3 +22,4 @@ declare function getPagesAndRoutes(): Promise<{
 declare function route(pageContext: Parameters<typeof routeInternal>[0]): Promise<{
     pageContextAddendum: import("../../shared-server-client/route/index.js").PageContextAfterRoute;
 }>;
+declare function getPageContextJson(pageContext: PageContextServer): string | ReadableStream<Uint8Array<ArrayBufferLike>>;

package/dist/server/__internal/index.js

@@ -1,10 +1,15 @@
 // Used by vike:build:pluginProdBuildEntry
 export { setGlobalContext_prodBuildEntry } from '../runtime/globalContext.js';
+// Used by the vike(app) of the @vikejs/* server adapters
+export { getMiddlewaresPipe_nonHandlers, getMiddlewaresPipe_handlers, } from '../runtime/universal-middleware/getMiddlewaresPipe.js';
+// Used by vike-react-rsc
+export { getPageContextJson };
 // Used by vite-plugin-vercel
 export { route, getPagesAndRoutes };
 import { route as routeInternal } from '../../shared-server-client/route/index.js';
 import { getGlobalContextServerInternal, initGlobalContext_getPagesAndRoutes } from '../runtime/globalContext.js';
 import { setNodeEnvProductionIfUndefined } from '../../utils/assertSetup.js';
+import { getPageContextJson as getPageContextJsonInternal } from '../runtime/renderPageServer/getPageContextJson.js';
 import '../assertEnvServer.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
@@ -30,3 +35,6 @@ async function route(pageContext) {
     // Old interface
     return { pageContextAddendum: pageContextFromRoute };
 }
+function getPageContextJson(pageContext) {
+    return getPageContextJsonInternal(pageContext);
+}

package/dist/server/createPageRenderer.d.ts

@@ -1,5 +1,5 @@
 export { createPageRenderer };
-import { renderPageServer } from './runtime/renderPageServer.js';
+import { renderPageServer_userLand } from './runtime/renderPageServer.js';
 import './assertEnvServer.js';
 type Options = {
     viteDevServer?: unknown;
@@ -10,4 +10,4 @@ type Options = {
     baseAssets?: string | null;
 };
 /** @deprecated */
-declare function createPageRenderer(options: Options): typeof renderPageServer;
+declare function createPageRenderer(options: Options): typeof renderPageServer_userLand;

package/dist/server/createPageRenderer.js

@@ -1,14 +1,14 @@
 export { createPageRenderer };
 // TO-DO/next-major-release: remove this file
 //import { SsrEnv, setSsrEnv } from './ssrEnv.js'
-import { renderPageServer } from './runtime/renderPageServer.js';
+import { renderPageServer_userLand } from './runtime/renderPageServer.js';
 import { assertWarning } from '../utils/assert.js';
 //import { importBuildWasLoaded } from './importBuild.js'
 import './assertEnvServer.js';
 /** @deprecated */
 function createPageRenderer(options) {
     showWarnings(options);
-    return renderPageServer;
+    return renderPageServer_userLand;
 }
 function showWarnings(options) {
     assertWarning(false, '`createPageRenderer()` is outdated, use `renderPage()` instead. See https://vike.dev/renderPage', { onlyOnce: true, showStackTrace: true });

package/dist/server/runtime/createDevMiddleware.js

@@ -1,7 +1,9 @@
 export { createDevMiddleware_ as createDevMiddleware };
 import '../assertEnvServer.js';
 const createDevMiddleware_ = async (...args) => {
-    const p = '../../node/createDevMiddleware.js';
+    let p = '../../node/createDevMiddleware.js';
+    // Absolute URL, because on Windows Vite's ssrLoadModule() resolves a relative dynamic import to `D:/...` and then fails to load it (e.g. if `vike` is linked and `$ vike dev` runs +serverEntry.js)
+    p = new URL(p, import.meta.url).href;
     const { createDevMiddleware } = await import(/*webpackIgnore: true*/ /* @vite-ignore */ p);
     return createDevMiddleware(...args);
 };

package/dist/server/runtime/globalContext.d.ts

@@ -54,6 +54,10 @@ declare function getGlobalContextServerInternal(): Promise<{
         _pageFilesAll: import("../__internal/index.js").PageFile[];
         _pageConfigs: import("../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & {
         isClientSide: false;
@@ -63,10 +67,9 @@ declare function getGlobalContextServerInternal(): Promise<{
         _isPrerendering: false;
         assetsManifest: null;
         _viteDevServer: ViteDevServer | undefined;
+        devMiddleware: import("vite").Connect.Server | null;
         viteConfig: ResolvedConfig | undefined;
     } & {
-        baseServer: string;
-        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -77,6 +80,14 @@ declare function getGlobalContextServerInternal(): Promise<{
                 inject: boolean | undefined;
             };
         };
+        baseServer: string;
+        baseAssets: string;
+        /**
+         * Every `+middleware` from Vike extensions, as well as Vike's built-in handler that renders pages.
+         *
+         * https://vike.dev/globalContext#middlewares
+         */
+        middlewares: import("./universal-middleware/core.js").Middleware[];
     } & {
         prerenderContext: PrerenderContext | undefined;
     }) | (Record<string, unknown> & {
@@ -102,6 +113,10 @@ declare function getGlobalContextServerInternal(): Promise<{
         _pageFilesAll: import("../__internal/index.js").PageFile[];
         _pageConfigs: import("../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & {
         isClientSide: false;
@@ -110,12 +125,11 @@ declare function getGlobalContextServerInternal(): Promise<{
         _isProduction: true;
         assetsManifest: ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: true;
         viteConfig: ResolvedConfig;
     } & {
-        baseServer: string;
-        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -126,6 +140,14 @@ declare function getGlobalContextServerInternal(): Promise<{
                 inject: boolean | undefined;
             };
         };
+        baseServer: string;
+        baseAssets: string;
+        /**
+         * Every `+middleware` from Vike extensions, as well as Vike's built-in handler that renders pages.
+         *
+         * https://vike.dev/globalContext#middlewares
+         */
+        middlewares: import("./universal-middleware/core.js").Middleware[];
     } & {
         prerenderContext: PrerenderContext | undefined;
     }) | (Record<string, unknown> & {
@@ -151,6 +173,10 @@ declare function getGlobalContextServerInternal(): Promise<{
         _pageFilesAll: import("../__internal/index.js").PageFile[];
         _pageConfigs: import("../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & {
         isClientSide: false;
@@ -159,12 +185,11 @@ declare function getGlobalContextServerInternal(): Promise<{
         _isProduction: true;
         assetsManifest: ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: false;
         viteConfig: null;
     } & {
-        baseServer: string;
-        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -175,6 +200,14 @@ declare function getGlobalContextServerInternal(): Promise<{
                 inject: boolean | undefined;
             };
         };
+        baseServer: string;
+        baseAssets: string;
+        /**
+         * Every `+middleware` from Vike extensions, as well as Vike's built-in handler that renders pages.
+         *
+         * https://vike.dev/globalContext#middlewares
+         */
+        middlewares: import("./universal-middleware/core.js").Middleware[];
     } & {
         prerenderContext: PrerenderContext | undefined;
     });
@@ -202,6 +235,10 @@ declare function getGlobalContextServerInternalOptional(): (Record<string, unkno
     _pageFilesAll: import("../__internal/index.js").PageFile[];
     _pageConfigs: import("../__internal/index.js").PageConfig[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: import("../__internal/index.js").PageConfig[];
+        pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & (({
     isClientSide: false;
@@ -211,6 +248,7 @@ declare function getGlobalContextServerInternalOptional(): (Record<string, unkno
     _isPrerendering: false;
     assetsManifest: null;
     _viteDevServer: ViteDevServer | undefined;
+    devMiddleware: import("vite").Connect.Server | null;
     viteConfig: ResolvedConfig | undefined;
 } | {
     isClientSide: false;
@@ -219,6 +257,7 @@ declare function getGlobalContextServerInternalOptional(): (Record<string, unkno
     _isProduction: true;
     assetsManifest: ViteManifest;
     _viteDevServer: null;
+    devMiddleware: null;
     _usesClientRouter: boolean;
     _isPrerendering: true;
     viteConfig: ResolvedConfig;
@@ -229,12 +268,11 @@ declare function getGlobalContextServerInternalOptional(): (Record<string, unkno
     _isProduction: true;
     assetsManifest: ViteManifest;
     _viteDevServer: null;
+    devMiddleware: null;
     _usesClientRouter: boolean;
     _isPrerendering: false;
     viteConfig: null;
 }) & {
-    baseServer: string;
-    baseAssets: string;
     viteConfigRuntime: {
         root: string;
         build: {
@@ -245,6 +283,14 @@ declare function getGlobalContextServerInternalOptional(): (Record<string, unkno
             inject: boolean | undefined;
         };
     };
+    baseServer: string;
+    baseAssets: string;
+    /**
+     * Every `+middleware` from Vike extensions, as well as Vike's built-in handler that renders pages.
+     *
+     * https://vike.dev/globalContext#middlewares
+     */
+    middlewares: import("./universal-middleware/core.js").Middleware[];
 })) & {
     prerenderContext: PrerenderContext | undefined;
 })) | null;
@@ -309,6 +355,10 @@ declare function createGlobalContext(virtualFileExportsGlobalEntry: unknown): Pr
     _pageFilesAll: import("../__internal/index.js").PageFile[];
     _pageConfigs: import("../__internal/index.js").PageConfig[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: import("../__internal/index.js").PageConfig[];
+        pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & (({
     isClientSide: false;
@@ -318,6 +368,7 @@ declare function createGlobalContext(virtualFileExportsGlobalEntry: unknown): Pr
     _isPrerendering: false;
     assetsManifest: null;
     _viteDevServer: ViteDevServer | undefined;
+    devMiddleware: import("vite").Connect.Server | null;
     viteConfig: ResolvedConfig | undefined;
 } | {
     isClientSide: false;
@@ -326,6 +377,7 @@ declare function createGlobalContext(virtualFileExportsGlobalEntry: unknown): Pr
     _isProduction: true;
     assetsManifest: ViteManifest;
     _viteDevServer: null;
+    devMiddleware: null;
     _usesClientRouter: boolean;
     _isPrerendering: true;
     viteConfig: ResolvedConfig;
@@ -336,12 +388,11 @@ declare function createGlobalContext(virtualFileExportsGlobalEntry: unknown): Pr
     _isProduction: true;
     assetsManifest: ViteManifest;
     _viteDevServer: null;
+    devMiddleware: null;
     _usesClientRouter: boolean;
     _isPrerendering: false;
     viteConfig: null;
 }) & {
-    baseServer: string;
-    baseAssets: string;
     viteConfigRuntime: {
         root: string;
         build: {
@@ -352,6 +403,14 @@ declare function createGlobalContext(virtualFileExportsGlobalEntry: unknown): Pr
             inject: boolean | undefined;
         };
     };
+    baseServer: string;
+    baseAssets: string;
+    /**
+     * Every `+middleware` from Vike extensions, as well as Vike's built-in handler that renders pages.
+     *
+     * https://vike.dev/globalContext#middlewares
+     */
+    middlewares: import("./universal-middleware/core.js").Middleware[];
 })) & {
     prerenderContext: PrerenderContext | undefined;
 }>;

package/dist/server/runtime/globalContext.js

@@ -56,6 +56,7 @@ import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
 import { debugFileChange, getVikeConfigErrorBuild, setVikeConfigError, } from '../../shared-server-node/getVikeConfigError.js';
 import { getVikeApiOperation } from '../../shared-server-node/api-context.js';
 import { hasAlreadyLogged } from './logErrorServer.js';
+import { getMiddlewares_globalContext } from './universal-middleware/core.js';
 import '../assertEnvServer.js';
 const debug = createDebug('vike:globalContext');
 const globalObject = getGlobalObject('runtime/globalContext.ts', getInitialGlobalObject());
@@ -490,14 +491,18 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
     if (!isProduction) {
         assert(globalContext); // main common requirement
         assert(!isPrerendering);
-        return {
+        const globalContextDev = {
             ...globalContextBase,
             _isProduction: false,
             _isPrerendering: false,
             assetsManifest: null,
             _viteDevServer: viteDevServer,
+            // https://vike.dev/globalContext#devMiddleware
+            devMiddleware: viteDevServer?.middlewares ?? null,
             viteConfig,
         };
+        addDevMiddlewareWarning(globalContextDev, viteDevServer);
+        return globalContextDev;
     }
     else {
         assert(globalObject.prodBuildEntry);
@@ -510,6 +515,7 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
             _isProduction: true,
             assetsManifest,
             _viteDevServer: null,
+            devMiddleware: null,
             _usesClientRouter: buildInfo.usesClientRouter,
         };
         if (isPrerendering) {
@@ -529,6 +535,25 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
         }
     }
 }
+function addDevMiddlewareWarning(globalContext, viteDevServer) {
+    if (!viteDevServer)
+        return;
+    const getMiddlewareMode = () => viteDevServer.config.server.middlewareMode;
+    Object.defineProperty(globalContext, 'devMiddleware', {
+        get() {
+            const middlewareMode = getMiddlewareMode();
+            if (!middlewareMode) {
+                assertWarning(false, `You don't need ${pc.cyan('globalContext.devMiddleware')} because the development middleware is already installed (Vite's ${pc.cyan('config.server.middlewareMode')} is ${pc.cyan(JSON.stringify(middlewareMode))}) — installing the development middleware twice might hang the server`, { onlyOnce: true });
+            }
+            return viteDevServer.middlewares;
+        },
+        enumerable: getMiddlewareMode()
+            ? true
+            : // So that spreading or serializing globalContext doesn't get the warning
+                false,
+        configurable: true,
+    });
+}
 async function addGlobalContextAsync(globalContext) {
     debug('addGlobalContextAsync()');
     let { viteConfigRuntime, buildInfo } = globalObject;
@@ -545,9 +570,17 @@ async function addGlobalContextAsync(globalContext) {
         }
     }
     assert(viteConfigRuntime);
+    const { baseServer, baseAssets } = resolveBaseRuntime(viteConfigRuntime, globalContext.config);
     return {
         viteConfigRuntime,
-        ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
+        baseServer,
+        baseAssets,
+        /**
+         * Every `+middleware` from Vike extensions, as well as Vike's built-in handler that renders pages.
+         *
+         * https://vike.dev/globalContext#middlewares
+         */
+        middlewares: getMiddlewares_globalContext(globalContext, baseServer),
     };
 }
 function clearGlobalContext() {

package/dist/server/runtime/index.d.ts

@@ -1,4 +1,4 @@
-export { renderPageServer as renderPage } from './renderPageServer.js';
+export { renderPageServer_userLand as renderPage } from './renderPageServer.js';
 export { escapeInject, dangerouslySkipEscape } from './renderPageServer/html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './renderPageServer/html/stream.js';
 export { PROJECT_VERSION as version } from '../../utils/PROJECT_VERSION.js';