vike 0.4.267-commit-5676e14 → 0.4.267-commit-e667e7c

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryAlias.js

@@ -1,35 +1,46 @@
 export { pluginServerEntryAlias };
 import { catchAllEntry } from '@universal-deploy/store';
+import pc from '@brillout/picocolors';
 import { pluginCommon } from './common.js';
 import { escapeRegex } from '../../../../utils/escapeRegex.js';
-import { assert } from '../../../../utils/assert.js';
+import { assert, assertWarning } from '../../../../utils/assert.js';
 import '../../assertEnvVite.js';
-const serverEntryAlias = 'vike:server-entry';
-const virtualFileId = '\0' + serverEntryAlias;
+const serverAlias = 'vike:server';
+// TO-DO/next-major-release: remove
+const serverAliasDeprecated = 'vike:server-entry';
+const virtualFileId = '\0' + serverAlias;
 // === Rolldown filter
-const filterRolldown = {
+const filterRolldownResolveId = {
     id: {
-        include: [new RegExp(escapeRegex(serverEntryAlias)), new RegExp(escapeRegex(virtualFileId))],
+        include: [serverAlias, serverAliasDeprecated, virtualFileId].map((id) => new RegExp(`^${escapeRegex(id)}$`)),
+    },
+};
+const filterRolldownLoad = {
+    id: {
+        include: [new RegExp(`^${escapeRegex(virtualFileId)}$`)],
     },
 };
 // ===
-/** Alias for virtual:ud:catch if no userland server entry */
+/** `vike:server` => alias for virtual:ud:catch-all, also re-exporting the non-default exports of +server.js (if any) */
 function pluginServerEntryAlias(serverFilePath) {
     return {
         name: 'vike:pluginUniversalDeploy:alias',
         resolveId: {
-            filter: filterRolldown,
-            handler() {
+            filter: filterRolldownResolveId,
+            handler(id) {
+                assert(id === serverAlias || id === serverAliasDeprecated || id === virtualFileId);
+                assertWarning(id !== serverAliasDeprecated, `${pc.cyan(serverAliasDeprecated)} is deprecated in favor of ${pc.cyan(serverAlias)}, e.g. replace ${pc.cyan(`"main": "${serverAliasDeprecated}"`)} with ${pc.cyan(`"main": "${serverAlias}"`)} in your wrangler.jsonc`, { onlyOnce: true });
                 if (!serverFilePath)
                     return catchAllEntry;
                 return virtualFileId;
             },
         },
         load: {
-            filter: filterRolldown,
-            handler() {
+            filter: filterRolldownLoad,
+            handler(id) {
+                assert(id === virtualFileId);
                 assert(serverFilePath);
-                // Also re-export non-default exports, to support Durable Objects
+                // Also re-export non-default exports, e.g. to support Durable Objects
                 return `import mod from ${JSON.stringify(catchAllEntry)};
 
 export * from ${JSON.stringify(serverFilePath)};

package/dist/node/vite/plugins/pluginUniversalDeploy.js

@@ -6,11 +6,13 @@ import { pluginServerEntryInject } from './pluginUniversalDeploy/pluginServerEnt
 import { getDeployConfig } from './pluginUniversalDeploy/getDeployConfig.js';
 import { pluginCommon } from './pluginUniversalDeploy/common.js';
 import { hasVikeServerOrVikePhoton } from './pluginUniversalDeploy/detectDeprecated.js';
-import { getServerConfig } from './pluginUniversalDeploy/getServerConfig.js';
+import { getServerConfig, getServerEntryFilePath_ifDev } from './pluginUniversalDeploy/getServerConfig.js';
 import { pluginServerEntryAlias } from './pluginUniversalDeploy/pluginServerEntryAlias.js';
 import { pluginUnwrapProdOptions } from './pluginUniversalDeploy/pluginUnwrapProdOptions.js';
+import { getViteCliCommand } from '../shared/isViteCli.js';
 import { unique } from '../../../utils/unique.js';
 import { assertUsage } from '../../../utils/assert.js';
+import pc from '@brillout/picocolors';
 import '../assertEnvVite.js';
 function pluginUniversalDeploy(vikeConfig) {
     if (hasVikeServerOrVikePhoton(vikeConfig))
@@ -25,9 +27,31 @@ function pluginUniversalDeploy(vikeConfig) {
             }),
             precompress(vikeConfig.config.precompress),
         ];
-    const { serverEntryVike, serverEntryId, serverFilePath } = serverConfig;
+    const { serverEntryVike, serverEntryId, serverFilePath, serverEntryFilePath } = serverConfig;
+    const isServerEntryDev = !!getServerEntryFilePath_ifDev(vikeConfig);
+    // Vite's CLI always starts Vite's own server => it can't run +serverEntry.js
+    assertUsage(!(isServerEntryDev && getViteCliCommand() === 'dev'), `${pc.cyan('+serverEntry.js')} (without ${pc.cyan('+server.js')}) requires ${pc.cyan('$ vike dev')} instead of ${pc.cyan('$ vite dev')} (because Vite's CLI always starts Vite's own server)`);
     return [
-        ...universalDeploy({ node: { precompress: vikeConfig.config.precompress } }),
+        ...(!serverEntryFilePath
+            ? universalDeploy({ node: { precompress: vikeConfig.config.precompress } })
+            : [
+                // +serverEntry.js is the production server entry dist/server/index.mjs (instead of @universal-deploy/node's server)
+                // https://vike.dev/serverEntry
+                ...universalDeploy({
+                    entry: {
+                        id: serverEntryFilePath,
+                        // Without +server.js, +serverEntry.js handles requests itself (it calls renderPage() instead of using vike:server) and `$ vike dev` runs it
+                        catchAll: !isServerEntryDev,
+                    },
+                }),
+                precompress(vikeConfig.config.precompress),
+                resolveTargets((targets) => {
+                    const target = targets[0];
+                    assertUsage(target === undefined, `+serverEntry cannot be used with ${target} (because it uses its own server entry)`);
+                }),
+                // dist/server/index.mjs loads dist/server/entry.mjs
+                pluginServerEntryInject(serverEntryFilePath),
+            ]),
         {
             name: 'vike:pluginUniversalDeploy:entries',
             config() {

package/dist/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.d.ts

@@ -6,8 +6,10 @@ export type { RuntimeEnv };
 export type { RuntimeEnvRuntime };
 import type { ConfigEnv, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
 import '../../assertEnvVite.js';
-type RuntimeEnv = RuntimeEnvRuntime | {
-    isForConfig: true;
+type RuntimeEnv = (RuntimeEnvRuntime & {
+    isConfigEnvironment?: undefined;
+}) | {
+    isConfigEnvironment: true;
 };
 type RuntimeEnvRuntime = {
     environmentName: string;

package/dist/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js

@@ -44,7 +44,7 @@ function getConfigValueSourceRelevantAnyEnv(configName, pageConfig) {
     return source;
 }
 function isRuntimeEnvMatch(configEnv, runtimeEnv) {
-    if ('isForConfig' in runtimeEnv)
+    if (runtimeEnv.isConfigEnvironment)
         return !!configEnv.config;
     // Runtime
     if (!configEnv[runtimeEnv.environmentName])

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

@@ -1,8 +1,10 @@
 export { addSsrMiddleware };
-import { renderPageServer } from '../../../server/runtime/renderPageServer.js';
-import { assertWarning } from '../../../utils/assert.js';
-import pc from '@brillout/picocolors';
+import { vikeUniversalMiddleware } from '../../../server/runtime/universal-middleware/vikeUniversalMiddleware.js';
+import { getAdapterRuntime } from '@universal-middleware/core';
+import { createRequestAdapter } from '@universal-middleware/node/request';
+import { sendResponse } from '@universal-middleware/node/response';
 import '../assertEnvVite.js';
+const requestAdapter = createRequestAdapter();
 function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled) {
     middlewares.use(async (req, res, next) => {
         if (res.headersSent)
@@ -10,26 +12,11 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
         const url = req.originalUrl || req.url;
         if (!url)
             return next();
-        const { headers } = req;
-        const pageContextInit = {
-            urlOriginal: url,
-            headersOriginal: headers,
-            _nodeDev: { req, res },
-        };
-        Object.defineProperty(pageContextInit, 'userAgent', {
-            get() {
-                // TO-DO/next-major-release: assertUsage() instead of assertWarning()
-                assertWarning(false, `${pc.cyan('pageContext.userAgent')} is deprecated: use ${pc.cyan("pageContext.headers['user-agent']")} instead.`, {
-                    showStackTrace: true,
-                    onlyOnce: true,
-                });
-                return headers['user-agent'];
-            },
-            enumerable: false,
-        });
-        let pageContext;
+        let response;
         try {
-            pageContext = await renderPageServer(pageContextInit);
+            const runtime = Object.assign(getAdapterRuntime('other', { params: undefined }), { req, res });
+            const context = { urlOriginal: url };
+            response = await vikeUniversalMiddleware(requestAdapter(req, res), context, runtime);
         }
         catch (err) {
             // Throwing an error in a connect middleware shuts down the server
@@ -39,7 +26,7 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
             // - We purposely don't use next(err) to align behavior: we use our own/copied implementation of buildErrorMessage() regardless of whether the user uses Vite's dev middleware or Vite's standalone dev server
             return next();
         }
-        if (pageContext.httpResponse.statusCode === 404 && isPreview && isPrerenderingEnabled) {
+        if (response.status === 404 && isPreview && isPrerenderingEnabled) {
             // Serve /dist/client/404.html instead
             return next();
         }
@@ -49,21 +36,6 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
                 if (value)
                     res.setHeader(name, value);
         }
-        const { httpResponse } = pageContext;
-        setHeadersWithMultipleCookies(res, httpResponse.headers);
-        res.statusCode = httpResponse.statusCode;
-        httpResponse.pipe(res);
+        await sendResponse(response, res);
     });
 }
-// A response can have several Set-Cookie headers: res.setHeader() would only keep the last one
-function setHeadersWithMultipleCookies(res, headers) {
-    const cookies = [];
-    headers.forEach(([name, value]) => {
-        if (name.toLowerCase() === 'set-cookie')
-            cookies.push(value);
-        else
-            res.setHeader(name, value);
-    });
-    if (cookies.length > 0)
-        res.setHeader('set-cookie', cookies);
-}

package/dist/node/vite/shared/findPageFiles.d.ts

@@ -2,4 +2,4 @@ export { findPageFiles };
 import type { ResolvedConfig } from 'vite';
 import type { FileType } from '../../../shared-server-client/getPageFiles/fileTypes.js';
 import '../assertEnvVite.js';
-declare function findPageFiles(config: ResolvedConfig, fileTypes: FileType[], isDev: boolean): Promise<string[]>;
+declare function findPageFiles(config: ResolvedConfig, fileTypes: FileType[]): Promise<string[]>;

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

@@ -2,22 +2,12 @@ export { findPageFiles };
 import { glob } from 'tinyglobby';
 import { scriptFileExtensionPattern } from '../../../utils/isScriptFile.js';
 import { toPosixPath } from '../../../utils/path.js';
-import { assertWarning } from '../../../utils/assert.js';
-import pc from '@brillout/picocolors';
 import { getOutDirs } from './getOutDirs.js';
 import '../assertEnvVite.js';
-async function findPageFiles(config, fileTypes, isDev) {
+async function findPageFiles(config, fileTypes) {
     const cwd = config.root;
     const { outDirRoot } = getOutDirs(config, undefined);
-    const timeBase = new Date().getTime();
     let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensionPattern}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false, expandDirectories: false });
     pageFiles = pageFiles.map((p) => '/' + toPosixPath(p));
-    const time = new Date().getTime() - timeBase;
-    if (isDev) {
-        // We only warn in dev, because while building it's expected to take a long time as tinyglobby is competing for resources with other tasks
-        assertWarning(time < 1.5 * 1000, `Finding your page files ${pc.cyan('**/*.page.*')} took an unexpected long time (${time}ms). Reach out to the vike maintainer.`, {
-            onlyOnce: 'slow-page-files-search',
-        });
-    }
     return pageFiles;
 }

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

@@ -56,11 +56,13 @@ type ConfigDefinition = {
     }) => boolean);
     /** Whether changes to the configuration should trigger a Vite restart. */
     vite?: boolean;
-    /** @experimental */
+    /** @internal */
     _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed, isDev: boolean) => unknown;
-    /** @experimental */
+    /** @internal */
     _valueIsFilePath?: true;
-    /** @experimental */
+    /** @internal */
+    _valueNotLoadedAtRuntime?: true;
+    /** @internal */
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     isDefinedByPeerDependency?: undefined;
 } | ConfigDefinitionDefinedByPeerDependency;

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

@@ -245,6 +245,15 @@ const metaBuiltIn = {
     server: {
         env: { server: true },
         global: true,
+        // virtual:vike:global-entry:server shouldn't import +server.js
+        // - Otherwise a +server.js calling `await getGlobalContext()` would wait for itself and hang indefinitely
+        _valueNotLoadedAtRuntime: true,
+    },
+    serverEntry: {
+        // The value is merely the file path of the server entry, which becomes dist/server/index.mjs — Vike never loads it as a config value
+        env: { config: true },
+        global: true,
+        _valueIsFilePath: true,
     },
     precompress: {
         env: { config: true },

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

@@ -79,6 +79,7 @@ declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinition
     vite?: boolean;
     _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed, isDev: boolean) => unknown;
     _valueIsFilePath?: true;
+    _valueNotLoadedAtRuntime?: true;
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     isDefinedByPeerDependency?: undefined;
 } | null;

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

@@ -531,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;

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

@@ -1,4 +1,5 @@
 export { setGlobalContext_prodBuildEntry } from '../runtime/globalContext.js';
+export { getMiddlewaresPipe_nonHandlers, getMiddlewaresPipe_handlers, } from '../runtime/universal-middleware/getMiddlewaresPipe.js';
 export { route, getPagesAndRoutes };
 export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
 import { route as routeInternal, type PageRoutes } from '../../shared-server-client/route/index.js';

package/dist/server/__internal/index.js

@@ -1,5 +1,7 @@
 // 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 vite-plugin-vercel
 export { route, getPagesAndRoutes };
 import { route as routeInternal } from '../../shared-server-client/route/index.js';

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/fetch.d.ts

@@ -1,10 +1,9 @@
 import '../assertEnvServer.js';
 declare const _default: {
-    fetch: (<T extends string>(request: Request, context: Universal.Context, runtime: import("@universal-middleware/core").RuntimeAdapterTarget<T>) => Promise<Response>) & import("@universal-middleware/core").WithUniversalSymbols<{
-        name: string;
-        method: ("GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT")[];
-        path: string;
-        immutable: true;
+    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/runtime/fetch.js

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

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

@@ -67,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: {
@@ -81,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> & {
@@ -118,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: {
@@ -134,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> & {
@@ -171,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: {
@@ -187,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;
     });
@@ -227,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;
@@ -235,6 +257,7 @@ declare function getGlobalContextServerInternalOptional(): (Record<string, unkno
     _isProduction: true;
     assetsManifest: ViteManifest;
     _viteDevServer: null;
+    devMiddleware: null;
     _usesClientRouter: boolean;
     _isPrerendering: true;
     viteConfig: ResolvedConfig;
@@ -245,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: {
@@ -261,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;
@@ -338,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;
@@ -346,6 +377,7 @@ declare function createGlobalContext(virtualFileExportsGlobalEntry: unknown): Pr
     _isProduction: true;
     assetsManifest: ViteManifest;
     _viteDevServer: null;
+    devMiddleware: null;
     _usesClientRouter: boolean;
     _isPrerendering: true;
     viteConfig: ResolvedConfig;
@@ -356,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: {
@@ -372,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';

package/dist/server/runtime/index.js

@@ -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';