vike 0.4.267 → 0.4.268

package/dist/server/runtime/renderPageServer.js

@@ -1,4 +1,5 @@
 export { renderPageServer };
+export { renderPageServer_userLand };
 export { getRequestTag };
 import { renderPageServerAfterRoute } from './renderPageServer/renderPageServerAfterRoute.js';
 import { createPageContextServer, createPageContextServerWithoutGlobalContext, } from './renderPageServer/createPageContextServer.js';
@@ -17,12 +18,13 @@ import { updateType } from '../../utils/updateType.js';
 import { getPageContextAddendumAbort, isAbortError, logAbort, addNewPageContextAborted, } from '../../shared-server-client/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPageServer/handlePageContextRequestUrl.js';
-import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageJson, createHttpResponseErrorFallback, createHttpResponseErrorFallback_noGlobalContext, createHttpResponseBaseIsMissing, createHttpResponseFromUniversalMiddleware, } from './renderPageServer/createHttpResponse.js';
+import { getPageContextPublicServer } from './renderPageServer/getPageContextPublicServer.js';
+import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageJson, createHttpResponseErrorFallback, createHttpResponseErrorFallback_noGlobalContext, createHttpResponseBaseIsMissing, } from './renderPageServer/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
 import { assertArguments } from './renderPageServer/assertArguments.js';
 import { log404 } from './renderPageServer/log404/index.js';
 import pc from '@brillout/picocolors';
-import { getPageContextClientSerializedAbort, getPageContextClientSerialized, } from './renderPageServer/html/serializeContext.js';
+import { getPageContextClientSerializedAbort } from './renderPageServer/html/serializeContext.js';
 import { getErrorPageId } from '../../shared-server-client/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPageServer/handleErrorWithoutErrorPage.js';
 import { loadPageConfigsLazyServerSide, } from './renderPageServer/loadPageConfigsLazyServerSide.js';
@@ -30,15 +32,19 @@ import { resolveRedirects } from './renderPageServer/resolveRedirects.js';
 import { getVikeConfigError } from '../../shared-server-node/getVikeConfigError.js';
 import { forkPageContext } from '../../shared-server-client/forkPageContext.js';
 import { getAsyncLocalStorage } from './asyncHook.js';
+import { getPageContextJson } from './renderPageServer/getPageContextJson.js';
+import { hasPlusMiddlewares } from './universal-middleware/core.js';
 import '../assertEnvServer.js';
-import { enhance, apply, universalSymbol, UniversalRouter, getAdapterRuntime, } from '@universal-middleware/core';
-import { createRequestAdapter } from '@universal-middleware/node/request';
 const globalObject = getGlobalObject('runtime/renderPageServer.ts', {
     httpRequestsCount: 0,
 });
-// `renderPageServer()` calls `renderPageServerNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that Vike never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
-async function renderPageServer(pageContextInit) {
+// The user's renderPage()
+function renderPageServer_userLand(pageContextInit) {
     assertArguments(...arguments);
+    return renderPageServer(pageContextInit, true);
+}
+// `renderPageServer()` calls `renderPageServerNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that Vike never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
+async function renderPageServer(pageContextInit, isCalledDirectlyByUser) {
     assert(hasProp(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
     assertIsUrl(pageContextInit.urlOriginal);
     onSetupRuntime();
@@ -50,14 +56,19 @@ async function renderPageServer(pageContextInit) {
     logHttpRequest(urlOriginalPretty, pageContextInit, requestId);
     const asyncLocalStorage = await getAsyncLocalStorage();
     const asyncStore = !asyncLocalStorage ? null : { requestId };
-    const render = async () => await renderPageServerEntryOnceBegin(pageContextInit, requestId, asyncStore);
+    const render = async () => await renderPageServerEntryOnce(pageContextInit, isCalledDirectlyByUser, requestId, asyncStore);
     const pageContextFinish = !asyncLocalStorage ? await render() : await asyncLocalStorage.run(asyncStore, render);
     logHttpResponse(urlOriginalPretty, pageContextFinish);
     checkType(pageContextFinish);
     assertPageContextFinish(pageContextFinish);
-    return pageContextFinish;
+    return getPageContextReturn(pageContextFinish);
 }
-async function renderPageServerEntryOnceBegin(pageContextInit, requestId, asyncStore) {
+function getPageContextReturn(pageContextFinish) {
+    if (!hasProp(pageContextFinish, '_globalContext', 'object'))
+        return pageContextFinish;
+    return getPageContextPublicServer(pageContextFinish);
+}
+async function renderPageServerEntryOnce(pageContextInit, isCalledDirectlyByUser, requestId, asyncStore) {
     // Invalid config
     {
         const vikeConfigError = getVikeConfigError();
@@ -92,17 +103,8 @@ async function renderPageServerEntryOnceBegin(pageContextInit, requestId, asyncS
         }
     }
     const { globalContext } = await getGlobalContextServerInternal();
+    assertUsage(!isCalledDirectlyByUser || !hasPlusMiddlewares(globalContext), `renderPage() doesn't run +middleware — see ${pc.underline('https://vike.dev/error/setup-middlewares')}`);
     const pageContextBegin = getPageContextBegin(pageContextInit, globalContext, requestId, asyncStore);
-    const middlewares = (globalContext.config.middleware ?? []).flat();
-    const renderPageServerEntry = () => renderPageServerEntryOnce(pageContextBegin, globalContext, requestId);
-    if (middlewares.length === 0) {
-        return renderPageServerEntry();
-    }
-    else {
-        return renderPageServerEntryWithMiddlewares(pageContextBegin, renderPageServerEntry, middlewares);
-    }
-}
-async function renderPageServerEntryOnce(pageContextBegin, globalContext, requestId) {
     // Check Base URL
     {
         const pageContextHttpResponse = await checkBaseUrl(pageContextBegin, globalContext);
@@ -125,6 +127,7 @@ async function renderPageServerEntryOnce(pageContextBegin, globalContext, reques
     return await renderPageServerEntryRecursive(pageContextBegin, globalContext, requestId);
 }
 async function renderPageServerEntryRecursive(pageContextBegin, globalContext, requestId) {
+    assert(requestId);
     catchInfiniteLoop(`[${getRequestTag(requestId)}] renderPageServerEntryRecursive()`);
     const pageContextNominalPageBegin = fork(pageContextBegin);
     const pageContextAddendumAbort = getPageContextAddendumAbort(pageContextBegin.pageContextsAborted);
@@ -217,7 +220,9 @@ async function renderPageServerEntryRecursive_onError(err, pageContextBegin, pag
     catch (errErrorPage) {
         // Handle `throw redirect()` and `throw render()` while rendering error page
         if (isAbortError(errErrorPage)) {
-            const handled = await handleAbort(errErrorPage, pageContextBegin, pageContextNominalPageBegin, requestId, pageContextErrorPageInit, globalContext);
+            const handled = await handleAbort(errErrorPage, pageContextBegin, 
+            // The error page is the page that aborted
+            pageContextErrorPageInit, requestId, pageContextErrorPageInit, globalContext);
             if (handled.pageContextReturn) {
                 // - throw redirect()
                 // - throw render(url)
@@ -239,42 +244,6 @@ async function renderPageServerEntryRecursive_onError(err, pageContextBegin, pag
     }
     return pageContextErrorPage;
 }
-const requestAdapter = createRequestAdapter();
-async function renderPageServerEntryWithMiddlewares(pageContext, renderPageServerEntry, middlewares) {
-    const router = new UniversalRouter(true, false);
-    let httpResponseVikeCore = undefined;
-    // Wrap rendering into universal-middleware routing
-    apply(router, [
-        enhance(async function adaptRenderPageServerEntryOnceInternal() {
-            const pageContextHttpResponse = await renderPageServerEntry();
-            const { httpResponse } = pageContextHttpResponse;
-            pageContext = pageContextHttpResponse;
-            httpResponseVikeCore = httpResponse;
-            const readable = httpResponse.getReadableWebStream();
-            return new Response(readable, {
-                status: httpResponse.statusCode,
-                headers: httpResponse.headers,
-            });
-        }, {
-            name: 'vike',
-            method: ['GET', 'POST', 'PUT', 'PATCH', 'HEAD', 'OPTIONS'],
-            path: '/**', // rou3 format
-            immutable: true, // avoids cloning the function we just created
-        }),
-        ...middlewares,
-    ]);
-    const handler = router[universalSymbol];
-    const request = pageContext._reqWeb ??
-        (pageContext._nodeDev
-            ? requestAdapter(pageContext._nodeDev.req, pageContext._nodeDev.res)
-            : new Request(new URL(pageContext.urlOriginal, 'http://localhost').toString(), {
-                headers: pageContext.headers ?? {},
-            }));
-    const res = await handler(request, {}, getAdapterRuntime('other', { params: undefined }));
-    const httpResponse = createHttpResponseFromUniversalMiddleware(res, httpResponseVikeCore?.earlyHints);
-    objectAssign(pageContext, { httpResponse });
-    return pageContext;
-}
 function logHttpRequest(urlOriginal, pageContextInit, requestId) {
     const pageContext = createPageContextServerWithoutGlobalContext(pageContextInit, requestId);
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), pageContext, 'info');
@@ -453,7 +422,7 @@ async function getPermanentRedirect(pageContextBegin, globalContext) {
         if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
         if (!originChanged)
-            urlTarget = prependBase(urlTarget, globalContext.baseServer);
+            urlTarget = modifyUrlPathname(urlTarget, (urlPathname) => prependBase(urlPathname, globalContext.baseServer));
         assert(urlTarget !== pageContext.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, pageContext, 'info');
@@ -470,14 +439,14 @@ pageContextNominalPageBegin, requestId, pageContextErrorPageInit, globalContext)
     logAbort(errAbort, globalContext._isProduction, pageContextNominalPageBegin);
     const pageContextAbort = errAbort._pageContextAbort;
     assert(pageContextAbort);
-    addNewPageContextAborted(pageContextBegin.pageContextsAborted, pageContextNominalPageBegin, pageContextAbort);
+    addNewPageContextAborted(pageContextBegin.pageContextsAborted, pageContextNominalPageBegin, pageContextAbort, getPageContextPublicServer);
     const pageContext = fork(pageContextBegin);
     const pageContextAddendumAbort = getPageContextAddendumAbort(pageContextBegin.pageContextsAborted);
     objectAssign(pageContext, pageContextAddendumAbort);
     assert(pageContextAddendumAbort === pageContextAbort);
     // Client-side navigation — [`pageContext.json` request](https://vike.dev/pageContext.json)
     if (pageContextBegin.isClientSideNavigation) {
-        let pageContextSerialized;
+        let pageContextJson;
         if (pageContextAbort.abortStatusCode) {
             const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
             const abortCall = pageContextAbort._abortCall;
@@ -487,12 +456,12 @@ pageContextNominalPageBegin, requestId, pageContextErrorPageInit, globalContext)
             objectAssign(pageContext, pageContextErrorPageInit, true);
             updateType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
-            pageContextSerialized = getPageContextClientSerialized(pageContext, false);
+            pageContextJson = getPageContextJson(pageContext);
         }
         else {
-            pageContextSerialized = getPageContextClientSerializedAbort(pageContextAbort, false);
+            pageContextJson = getPageContextClientSerializedAbort(pageContextAbort, false);
         }
-        const httpResponse = await createHttpResponsePageJson(pageContextSerialized);
+        const httpResponse = await createHttpResponsePageJson(pageContextJson, pageContext);
         objectAssign(pageContext, { httpResponse });
         return { pageContextReturn: pageContext };
     }

package/dist/server/runtime/universal-middleware/core.d.ts

@@ -0,0 +1,25 @@
+export { getMiddlewares_globalContext };
+export { getMiddlewares_withErrorHandling };
+export { hasPlusMiddlewares };
+export { routeCatchAll };
+export { mergeContext };
+export type { Middleware };
+import { type EnhancedMiddleware, type UniversalMiddleware } from '@universal-middleware/core';
+import type { ConfigResolved } from '../../../types/Config/ConfigResolved.js';
+import '../../assertEnvServer.js';
+type Middleware = EnhancedMiddleware & {
+    isHandler: boolean;
+};
+declare const routeCatchAll: {
+    readonly name: 'vike';
+    readonly method: ["GET", "POST", "PUT", "PATCH", "HEAD", "OPTIONS"];
+    readonly path: '/**';
+};
+declare function getMiddlewares_globalContext(globalContext: {
+    config: ConfigResolved;
+}, baseServer: string): Middleware[];
+declare function getMiddlewares_withErrorHandling(): Promise<Middleware[]>;
+declare function hasPlusMiddlewares(globalContext: {
+    config: ConfigResolved;
+}): boolean;
+declare function mergeContext(middleware: EnhancedMiddleware): UniversalMiddleware;

package/dist/server/runtime/universal-middleware/core.js

@@ -0,0 +1,167 @@
+export { getMiddlewares_globalContext };
+export { getMiddlewares_withErrorHandling };
+export { hasPlusMiddlewares };
+export { routeCatchAll };
+export { mergeContext };
+import { createMatcher, enhance, getUniversal, getUniversalProp, isHandler, methodSymbol, orderSymbol, pathSymbol, nameSymbol, runsSymbol, } from '@universal-middleware/core';
+import { parseUrl } from '../../../utils/parseUrl.js';
+import { prependBase } from '../../../utils/parseUrl-extras.js';
+import { handlePageContextRequestUrl } from '../renderPageServer/handlePageContextRequestUrl.js';
+import { renderPageServer } from '../renderPageServer.js';
+import { getGlobalContextServerInternal, initGlobalContext_renderPage } from '../globalContext.js';
+import { getVikeConfigError } from '../../../shared-server-node/getVikeConfigError.js';
+import { assertWarning } from '../../../utils/assert.js';
+import pc from '@brillout/picocolors';
+import '../../assertEnvServer.js';
+const routeCatchAll = {
+    name: 'vike',
+    method: ['GET', 'POST', 'PUT', 'PATCH', 'HEAD', 'OPTIONS'],
+    path: '/**',
+};
+// Vike's pages
+const renderPageServer_universalMiddleware = enhance(renderPageServer_universal, routeCatchAll);
+// globalContext.middlewares — every +middleware and Vike's handler that renders pages
+function getMiddlewares_globalContext(globalContext, baseServer) {
+    return [
+        ...getMiddlewares_config(globalContext).map((plusMiddleware) => wrapWithVikeNormalizedURL(plusMiddleware, baseServer)),
+        renderPageServer_universalMiddleware,
+    ].map(withIsHandler);
+}
+// Returns globalContext.middlewares, or middlewares_errorHandling upon an invalid config
+async function getMiddlewares_withErrorHandling() {
+    if (getVikeConfigError())
+        return middlewares_errorHandling;
+    try {
+        await initGlobalContext_renderPage();
+    }
+    catch {
+        return middlewares_errorHandling;
+    }
+    if (getVikeConfigError())
+        return middlewares_errorHandling;
+    const { globalContext } = await getGlobalContextServerInternal();
+    return globalContext.middlewares;
+}
+// Upon an invalid config: let renderPageServer() answer every request with the error (`+middleware` isn't defined upon config error)
+const middlewares_errorHandling = [enhance(renderPageServer_universal, { name: 'vike:error-handling' })].map(withIsHandler);
+async function renderPageServer_universal(request, context, runtime) {
+    const pageContextInit = {
+        urlOriginal: request.url, // Let `context` override it, e.g. `$ vike dev` passes the URL's path
+        headersOriginal: request.headers,
+        req: 'req' in runtime ? runtime.req : null,
+        res: 'res' in runtime ? runtime.res : null,
+        runtime,
+        ...context,
+    };
+    addUserAgent_deprecated(pageContextInit, request, runtime);
+    const pageContext = await renderPageServer(pageContextInit, false);
+    const { httpResponse } = pageContext;
+    return new Response(httpResponse.getReadableWebStream(), {
+        status: httpResponse.statusCode,
+        headers: httpResponse.headers,
+    });
+}
+// List of +middleware
+function getMiddlewares_config(globalContext) {
+    return (globalContext.config.middleware ?? []).flat();
+}
+// Does a +middleware exist?
+function hasPlusMiddlewares(globalContext) {
+    return getMiddlewares_config(globalContext).length > 0;
+}
+// Handle:
+// - Base URL
+// - JSON URL `.pageContext.json`
+function wrapWithVikeNormalizedURL(plusMiddleware, baseServer) {
+    const { path, method, ...options } = getOptions(plusMiddleware);
+    if (path)
+        assertPath(options.name, path, baseServer);
+    if (isHandler(plusMiddleware)) {
+        // A handler is a route of the server, which matches it: its path gets the Base URL. (`enhance()` clones it, so that marking it `isHandler` leaves the extension's export untouched.)
+        return enhance(plusMiddleware, path ? { path: prependBase(path.startsWith('/') ? path : `/${path}`, baseServer) } : {});
+    }
+    const isMatch = path && createMatcher(path, method);
+    const plusMiddlewareMerged = mergeContext(plusMiddleware);
+    return enhance(async (request, context, runtime) => {
+        const { isPageContextJsonRequest, urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(request.url);
+        if (isMatch) {
+            const { href, isBaseMissing } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);
+            if (isBaseMissing || !isMatch(new Request(href, { method: request.method })))
+                return;
+        }
+        const answer = await getUniversal(plusMiddlewareMerged)(request, context, runtime);
+        return isPageContextJsonRequest ? toPageContextJsonAnswer(answer) : answer;
+    }, {
+        ...options,
+        // Whatever its order, it doesn't run once a Response exists
+        runs: 'until-response',
+    });
+}
+// A +middleware's answer to a `.pageContext.json` request. Its own Response, or a response function's replacement of
+// Vike's JSON, becomes a 404 without JSON: the client router then reloads the page, so that the page's own request shows
+// the +middleware's answer (e.g. a 401, a redirect or a login page).
+function toPageContextJsonAnswer(answer) {
+    const toReload = (response) => {
+        const headers = new Headers(response.headers);
+        headers.delete('content-type');
+        return new Response(response.body, { status: 404, headers });
+    };
+    // The +middleware answered instead of the page
+    if (answer instanceof Response)
+        return toReload(answer);
+    if (typeof answer !== 'function')
+        return answer;
+    return async (response) => {
+        const replaced = await answer(response);
+        // Vike's JSON, possibly re-encoded, keeps its status and its JSON Content-Type
+        const isVikeJson = replaced?.status === response.status && replaced.headers.get('content-type')?.includes('application/json');
+        return replaced && (isVikeJson ? replaced : toReload(replaced));
+    };
+}
+// Warns about a path that starts with the Base URL
+function assertPath(name, path, baseServer) {
+    const base = baseServer.replace(/\/$/, '');
+    if (!base || (path !== base && !path.startsWith(`${base}/`)))
+        return;
+    assertWarning(false, `The +middleware ${name ? `${pc.bold(name)} ` : ''}has the path ${pc.cyan(path)}, which starts with the Base URL ${pc.cyan(baseServer)}. A +middleware path is relative to the Base URL, use ${pc.cyan(path.slice(base.length) || '/')} instead.`, { onlyOnce: `middleware-path:${name}:${path}` });
+}
+// Universal Middleware replaces the context with the one a middleware returns: Vike merges it into a new object, as a
+// +middleware or a user-land universal middleware returns only what it adds, and an adapter may reuse the context
+function mergeContext(middleware) {
+    return enhance(async (request, context, runtime) => {
+        const result = await getUniversal(middleware)(request, context, runtime);
+        if (!result || result instanceof Response || typeof result === 'function')
+            return result;
+        return { ...context, ...result };
+    }, getOptions(middleware));
+}
+// The options `enhance()` gave a middleware, also when an adapter wraps it, without the unset ones: Universal Middleware sorts an `order` set to `undefined` as `NaN`
+function getOptions(middleware) {
+    const options = {
+        name: getUniversalProp(middleware, nameSymbol),
+        path: getUniversalProp(middleware, pathSymbol),
+        method: getUniversalProp(middleware, methodSymbol),
+        order: getUniversalProp(middleware, orderSymbol),
+        runs: getUniversalProp(middleware, runsSymbol),
+    };
+    return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+}
+function withIsHandler(middleware) {
+    return Object.assign(middleware, { isHandler: isHandler(middleware) });
+}
+function addUserAgent_deprecated(pageContextInit, request, runtime) {
+    // Backwards compatibility for `$ vike dev` and `$ vike preview`
+    if (runtime.adapter === 'other' && 'req' in runtime) {
+        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 request.headers.get('user-agent') ?? undefined;
+            },
+            enumerable: false,
+        });
+    }
+}

package/dist/server/runtime/universal-middleware/deprecated-export.d.ts

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

package/dist/server/runtime/universal-middleware/deprecated-export.js

@@ -0,0 +1,10 @@
+export default vikeUniversalMiddleware;
+// TO-DO/next-major-release: remove this export (the entire file)
+import { vikeUniversalMiddleware } from './vikeUniversalMiddleware.js';
+import { assertWarning } from '../../../utils/assert.js';
+import '../../assertEnvServer.js';
+assertWarning(false, [
+    "You're using a deprecated Vike extension:",
+    '- If you use one of the following, update to its latest version: @vikejs/hono, @vikejs/express, @vikejs/fastify, @vikejs/h3, or @vikejs/elysia',
+    '- If you use vike-photon or vike-server, migrate to +server.js — see https://vike.dev/migration/server',
+].join('\n'), { onlyOnce: true });

package/dist/server/runtime/universal-middleware/getMiddlewaresPipe.d.ts

@@ -0,0 +1,15 @@
+export { getMiddlewaresPipe_nonHandlers };
+export { getMiddlewaresPipe_handlers };
+export { pipeNonHandlers };
+import { type UniversalHandler, type UniversalMiddleware } from '@universal-middleware/core';
+import { type Middleware } from './core.js';
+import '../../assertEnvServer.js';
+/**
+ * What `vike(app, middlewares)` runs after the app's routes: the middlewares (looked up upon each request) that are handlers, as one universal handler (the pipe).
+ */
+declare function getMiddlewaresPipe_handlers(middlewaresUserLand: object[]): UniversalHandler;
+/**
+ * What `vike(app, middlewares)` applies before the app's routes: the middlewares (looked up upon each request) that aren't handlers, as one universal middleware (the pipe).
+ */
+declare function getMiddlewaresPipe_nonHandlers(middlewaresUserLand: object[]): UniversalMiddleware;
+declare function pipeNonHandlers(middlewares: Middleware[], nonHandlersUserLand: UniversalMiddleware[]): UniversalMiddleware;

package/dist/server/runtime/universal-middleware/getMiddlewaresPipe.js

@@ -0,0 +1,51 @@
+export { getMiddlewaresPipe_nonHandlers };
+export { getMiddlewaresPipe_handlers };
+export { pipeNonHandlers };
+import { enhance, isHandler, pipeRoute, } from '@universal-middleware/core';
+import { getMiddlewares_withErrorHandling, mergeContext } from './core.js';
+import '../../assertEnvServer.js';
+/**
+ * What `vike(app, middlewares)` runs after the app's routes: the middlewares (looked up upon each request) that are handlers, as one universal handler (the pipe).
+ */
+function getMiddlewaresPipe_handlers(
+// `object[]`: the user-land universal middlewares can come from another copy of @universal-middleware/core, whose types don't match this copy's
+middlewaresUserLand) {
+    const handlersUserLand = middlewaresUserLand.filter(isHandler);
+    const router = pipe((middlewares) => pipeRoute([...handlersUserLand, ...middlewares.filter((middleware) => middleware.isHandler)]));
+    return enhance(async (request, context, runtime) => {
+        return ((await router(request, context, runtime)) ??
+            // Fallback when no handler answers
+            new Response('Not Found', { status: 404 }));
+    }, {
+        name: 'vike:handlers',
+        method: ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'CONNECT', 'OPTIONS', 'TRACE', 'PATCH'],
+        path: '/**',
+    });
+}
+/**
+ * What `vike(app, middlewares)` applies before the app's routes: the middlewares (looked up upon each request) that aren't handlers, as one universal middleware (the pipe).
+ */
+function getMiddlewaresPipe_nonHandlers(
+// `object[]`: the user-land universal middlewares can come from another copy of @universal-middleware/core, whose types don't match this copy's
+middlewaresUserLand) {
+    const nonHandlersUserLand = middlewaresUserLand.filter((middleware) => !isHandler(middleware));
+    return enhance(pipe((middlewares) => pipeNonHandlers(middlewares, nonHandlersUserLand)), { name: 'vike:nonHandlers' });
+}
+function pipeNonHandlers(middlewares, nonHandlersUserLand) {
+    const nonHandlers = [
+        ...middlewares.filter((middleware) => !middleware.isHandler),
+        ...nonHandlersUserLand.map((middleware) => mergeContext(enhance(middleware, { runs: 'always' }))),
+    ];
+    return pipeRoute(nonHandlers);
+}
+function pipe(getPipe) {
+    // Caching: the list changes only when the config does, so getPipe() runs once per list
+    const cache = new WeakMap();
+    return async (request, context, runtime) => {
+        const middlewares = await getMiddlewares_withErrorHandling();
+        let ret = cache.get(middlewares);
+        if (!ret)
+            cache.set(middlewares, (ret = getPipe(middlewares)));
+        return ret(request, context, runtime);
+    };
+}

package/dist/server/runtime/universal-middleware/vikeUniversalMiddleware.d.ts

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

package/dist/server/runtime/universal-middleware/vikeUniversalMiddleware.js

@@ -0,0 +1,22 @@
+export { vikeUniversalMiddleware };
+import { enhance, getAdapterRuntime } from '@universal-middleware/core';
+import { getMiddlewaresPipe_handlers, getMiddlewaresPipe_nonHandlers } from './getMiddlewaresPipe.js';
+import { routeCatchAll } from './core.js';
+import '../../assertEnvServer.js';
+// The Universal Middleware for Vike's built-in server.
+// - The same two pipes that `vike(app)` applies, but without any user-land middlewares (there aren't any)
+const vikeUniversalMiddleware = enhance(handler, routeCatchAll);
+const pipeNonHandlers = getMiddlewaresPipe_nonHandlers([]);
+const pipeHandlers = getMiddlewaresPipe_handlers([]);
+async function handler(request, context = {}, runtime = getAdapterRuntime('other', { params: undefined })) {
+    // A copy: Universal Middleware's `pipe()` writes a returned context into it when a response function follows, and a Cloudflare worker's `env` (its context) is shared by all requests
+    context = { ...context };
+    const answer = await pipeNonHandlers(request, context, runtime);
+    if (answer instanceof Response)
+        return answer;
+    // The context the +middleware returned
+    if (answer && typeof answer === 'object')
+        context = answer;
+    const response = await pipeHandlers(request, context, runtime);
+    return typeof answer === 'function' ? ((await answer(response)) ?? response) : response;
+}

package/dist/shared-server-client/createGlobalContextShared.d.ts

@@ -42,6 +42,10 @@ declare function createGlobalContextShared<GlobalContextAdded extends {}, Global
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: PageConfigRuntime[];
+        pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & GlobalContextAdded & Awaited<GlobalContextAddedAsync>>;
 type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
@@ -74,5 +78,9 @@ declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown)
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: PageConfigRuntime[];
+        pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 };

package/dist/shared-server-client/createGlobalContextShared.js

@@ -79,7 +79,7 @@ addGlobalContextTmp, addGlobalContextAsync) {
     }
 }
 function createGlobalContextBase(virtualFileExportsGlobalEntry) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
+    const { pageFilesAll, pageConfigs, pageConfigGlobal, environmentEntries } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
     const globalContextAddendum = resolveGlobalContextConfig(pageConfigs, pageConfigGlobal);
     const globalContext = {
@@ -94,6 +94,7 @@ function createGlobalContextBase(virtualFileExportsGlobalEntry) {
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
+        _environmentEntries: environmentEntries,
         _allPageIds: allPageIds,
         ...globalContextAddendum,
     };

package/dist/shared-server-client/getPageContextPublicShared.js

@@ -3,14 +3,12 @@ export { assertPropertyGetters };
 import { assert, assertWarning } from '../utils/assert.js';
 import { compareString } from '../utils/compareString.js';
 import { isPropertyGetter } from '../utils/isPropertyGetter.js';
-import { addIs404ToPageProps } from './addIs404ToPageProps.js';
 import { getGlobalContextPublicShared } from './getGlobalContextPublicShared.js';
 import { getPublicProxy } from './getPublicProxy.js';
 function getPageContextPublicShared(pageContext) {
     assert(!pageContext._isProxyObject);
     assert(!pageContext.globalContext); // pageContext.globalContext should only be available to users — Vike itself should use pageContext._globalContext instead
     assert(pageContext._isOriginalObject); // ensure we preserve the original object reference
-    addIs404ToPageProps(pageContext);
     // TO-DO/next-major-release: remove
     if (!('_pageId' in pageContext)) {
         Object.defineProperty(pageContext, '_pageId', {

package/dist/shared-server-client/getPageFiles/parseVirtualFileExportsGlobalEntry.d.ts

@@ -1,8 +1,16 @@
 export { parseVirtualFileExportsGlobalEntry };
+export { parseGlobalEntryPageConfigs };
+export type { EnvironmentEntry };
 import { type PageFile } from './getPageFileObject.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../types/PageConfig.js';
 declare function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry: unknown): {
     pageFilesAll: PageFile[];
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;
+    environmentEntries: Record<string, null | EnvironmentEntry>;
+};
+type EnvironmentEntry = ReturnType<typeof parseGlobalEntryPageConfigs>;
+declare function parseGlobalEntryPageConfigs(virtualFileExportsGlobalEntry: unknown): {
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
 };

package/dist/shared-server-client/getPageFiles/parseVirtualFileExportsGlobalEntry.js

@@ -1,4 +1,5 @@
 export { parseVirtualFileExportsGlobalEntry };
+export { parseGlobalEntryPageConfigs };
 // TO-DO/next-major-release: remove old design code, and remove all assertions.
 import { assert } from '../../utils/assert.js';
 import { cast } from '../../utils/cast.js';
@@ -6,6 +7,7 @@ import { hasProp } from '../../utils/hasProp.js';
 import { isArray } from '../../utils/isArray.js';
 import { isCallable } from '../../utils/isCallable.js';
 import { isObject } from '../../utils/isObject.js';
+import { objectMap } from '../../utils/objectMap.js';
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
@@ -21,12 +23,12 @@ function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry) {
     assert(hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page.client') ||
         hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page.server'));
     assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesList', 'string[]'));
-    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigsSerialized'));
-    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigGlobalSerialized'));
-    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExportsGlobalEntry;
-    assertPageConfigsSerialized(pageConfigsSerialized);
-    assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
-    const { pageConfigs, pageConfigGlobal } = parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized);
+    const { pageConfigs, pageConfigGlobal } = parseGlobalEntryPageConfigs(virtualFileExportsGlobalEntry);
+    // The global entries of the additional environments (e.g. `rsc`)
+    // - `null` in development: they're imported with environment.runner.import()
+    const environmentEntries = hasProp(virtualFileExportsGlobalEntry, 'environmentEntries', 'object')
+        ? objectMap(virtualFileExportsGlobalEntry.environmentEntries, (environmentEntry) => environmentEntry === null ? null : parseGlobalEntryPageConfigs(environmentEntry))
+        : {};
     const pageFilesMap = {};
     parseGlobResult(virtualFileExportsGlobalEntry.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
@@ -72,7 +74,15 @@ function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry) {
     pageFilesAll.forEach(({ filePath }) => {
         assert(!filePath.includes('\\'));
     });
-    return { pageFilesAll, pageConfigs, pageConfigGlobal };
+    return { pageFilesAll, pageConfigs, pageConfigGlobal, environmentEntries };
+}
+function parseGlobalEntryPageConfigs(virtualFileExportsGlobalEntry) {
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigsSerialized'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExportsGlobalEntry;
+    assertPageConfigsSerialized(pageConfigsSerialized);
+    assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
+    return parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized);
 }
 function parseGlobResult(globObject) {
     const ret = [];

package/dist/shared-server-client/hooks/execHook.d.ts

@@ -38,7 +38,7 @@ declare function execHookSingleWithReturn<PageContext extends PageContextExecHoo
 }>;
 declare function isUserHookError(err: unknown): false | HookLoc;
 declare function execHookSingleWithoutPageContext<HookReturn>(hook: Omit<HookInternal, 'hookFn'>, globalContext: GlobalContextPublicMinimum, hookFnCaller: () => HookReturn): Promise<HookReturn>;
-declare function execHookSingleSync<PageContext extends PageContextExecHook>(hook: Omit<HookInternal<PageContext>, 'hookTimeout'>, globalContext: GlobalContextPublicMinimum, pageContext: PageContext | null, getPageContextPublic: (pageContext: PageContext) => PageContext, hookFnCaller?: () => unknown): {
+declare function execHookSingleSync<PageContext extends PageContextExecHook>(hook: Omit<HookInternal<PageContext>, 'hookTimeout'>, globalContext: GlobalContextPublicMinimum, pageContext: PageContext | null, getPageContextPublic: (pageContext: PageContext) => PageContext, hookFnCaller?: (pageContextPublic: PageContext | null) => unknown): {
     hookReturn: unknown;
 };
 type HookPublic = {