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

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

@@ -1,21 +1,72 @@
 export { renderPageServer };
+export { renderPageServer_userLand };
 export { getRequestTag };
 export type { PageContextInit };
-export type { PageContextInitInternal };
 export type { PageContextBegin };
 export type { RequestTag };
 import { type PageContextAborted } from '../../shared-server-client/route/abort.js';
 import { type GlobalContextServerInternal } from './globalContext.js';
 import { type HttpResponse } from './renderPageServer/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
-import type { PageContextInit, PageContextInitInternal } from '../../types/PageContext.js';
+import type { PageContextInit, PageContextInternalServer } from '../../types/PageContext.js';
 import { type AsyncStore } from './asyncHook.js';
 import '../assertEnvServer.js';
 type PageContextBegin = ReturnType<typeof getPageContextBegin>;
-declare function renderPageServer<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInitInternal>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
+declare function renderPageServer_userLand<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInit>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
+    httpResponse: HttpResponse;
+} & Partial<import("../../shared-server-client/getPageFiles.js").PageContextConfig & {
+    isPageContext: true;
+    Page: import("../../types/Config.js").Config['Page'];
+    routeParams: Record<string, string>;
+    data: unknown;
+    headersResponse: Headers;
+    is404: boolean | null;
+    isClientSideNavigation: boolean;
+    abortReason?: unknown;
+    abortStatusCode?: import("../../shared-server-client/route/abort.js").AbortStatusCode;
+    errorWhileRendering?: unknown;
+    pageId: string | null;
+    from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+    source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+    sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+    pageExports: Record<string, unknown>;
+    isBaseMissing?: true;
+} & PageContextInit & {
+    urlOriginal: string;
+} & {
+    urlParsed: import("../../utils/parseUrl.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    urlParsed: Omit<import("../../utils/parseUrl.js").UrlPublic, "hash" | "hashOriginal" | "hashString"> & {
+        hash: '';
+        hashString: null;
+        hashOriginal: null;
+    };
+} & {
+    headers: Record<string, string> | null;
+    isClientSide: false;
+    isPrerendering: boolean;
+    globalContext: import("../../types/GlobalContext.js").GlobalContextServer;
+    cspNonce: string | null;
+    pageContextsAborted: Partial<PageContextServer<unknown>>[];
+    environments?: Record<string, {
+        config: import("../../shared-server-client/getPageFiles.js").PageContextConfig['config'];
+        pageContext: PageContextServer<unknown>;
+    }> | undefined;
+    isHydration?: undefined;
+    isBackwardNavigation?: undefined;
+    isHistoryNavigation?: undefined;
+    previousPageContext?: undefined;
+} & {
+    dangerouslyUseInternals: import("../../shared-server-client/getPublicProxy.js").DangerouslyUseInternals<PageContextInternalServer & import("./renderPageServer/renderPageServerAfterRoute.js").PageContextAfterRender & import("./renderPageServer/getPageContextPublicServer.js").PageContextPublicServer>;
+} & Vike.PageContext & Vike.PageContextServer & {
+    content?: string | Uint8Array | ReadableStream<Uint8Array>;
+} & PageContextUserAdded>>;
+declare function renderPageServer<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInit>(pageContextInit: PageContextInitUser, isCalledDirectlyByUser: boolean): Promise<PageContextInitUser & {
     httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;
-declare function getPageContextBegin(pageContextInit: PageContextInitInternal, globalContext: GlobalContextServerInternal, requestId: number, asyncStore: AsyncStore): {
+declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, requestId: number, asyncStore: AsyncStore): {
     _isOriginalObject: true;
     isPageContext: true;
 } & {
@@ -23,12 +74,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
     isPrerendering: boolean;
     _requestId: number;
 } & PageContextInit & {
-    _nodeDev?: {
-        req: import("http").IncomingMessage;
-        res: import("http").ServerResponse;
-    };
-    _reqWeb?: Request;
-} & {
     _globalContext: ({
         config: import("../../types/index.js").ConfigResolved;
         _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
@@ -65,6 +110,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
         _isPrerendering: false;
         assetsManifest: null;
         _viteDevServer: import("vite").ViteDevServer | undefined;
+        devMiddleware: import("vite").Connect.Server | null;
         viteConfig: import("vite").ResolvedConfig | undefined;
     } | {
         isClientSide: false;
@@ -73,6 +119,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: true;
         viteConfig: import("vite").ResolvedConfig;
@@ -83,12 +130,11 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: false;
         viteConfig: null;
     }) & {
-        baseServer: string;
-        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -99,6 +145,9 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
                 inject: boolean | undefined;
             };
         };
+        baseServer: string;
+        baseAssets: string;
+        middlewares: import("./universal-middleware/core.js").Middleware[];
     })) & {
         prerenderContext: import("../../types/index.js").PrerenderContext | undefined;
     };
@@ -106,12 +155,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
     _baseServer: string;
     _baseAssets: string;
     _pageContextInit: PageContextInit & {
-        _nodeDev?: {
-            req: import("http").IncomingMessage;
-            res: import("http").ServerResponse;
-        };
-        _reqWeb?: Request;
-    } & {
         headers?: Record<string, unknown>;
     };
     _urlHandler: ((url: string) => string) | null;

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';
@@ -18,7 +19,7 @@ import { getPageContextAddendumAbort, isAbortError, logAbort, addNewPageContextA
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPageServer/handlePageContextRequestUrl.js';
 import { getPageContextPublicServer } from './renderPageServer/getPageContextPublicServer.js';
-import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageJson, createHttpResponseErrorFallback, createHttpResponseErrorFallback_noGlobalContext, createHttpResponseBaseIsMissing, createHttpResponseFromUniversalMiddleware, } from './renderPageServer/createHttpResponse.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';
@@ -32,15 +33,18 @@ import { getVikeConfigError } from '../../shared-server-node/getVikeConfigError.
 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();
@@ -52,7 +56,7 @@ 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);
@@ -64,7 +68,7 @@ function getPageContextReturn(pageContextFinish) {
         return pageContextFinish;
     return getPageContextPublicServer(pageContextFinish);
 }
-async function renderPageServerEntryOnceBegin(pageContextInit, requestId, asyncStore) {
+async function renderPageServerEntryOnce(pageContextInit, isCalledDirectlyByUser, requestId, asyncStore) {
     // Invalid config
     {
         const vikeConfigError = getVikeConfigError();
@@ -99,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);
@@ -249,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');

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/page-configs/serialize/serializeConfigValues.js

@@ -207,6 +207,8 @@ function getConfigValuesBase(pageConfig, runtimeEnv, isEager) {
         assert(configDef);
         if (isEager !== null && isEager !== !!configDef.eager)
             return 'SKIP';
+        if (configDef._valueNotLoadedAtRuntime && !runtimeEnv.isConfigEnvironment)
+            return 'SKIP';
         if (!configDef.cumulative) {
             const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
             const source = sourcesRelevant[0];

package/dist/types/Config.d.ts

@@ -540,7 +540,7 @@ type ConfigBuiltIn = {
      *
      * The middlewares defined via `+middleware` are so called "Universal Middleware" — they work with any JavaScript server (Hono, Express, Cloudflare, ...).
      *
-     * https://github.com/magne4000/universal-middleware
+     * https://vike.dev/middleware
      */
     middleware?: EnhancedMiddleware | EnhancedMiddleware[];
     /**
@@ -551,6 +551,14 @@ type ConfigBuiltIn = {
      * https://vike.dev/server
      */
     server?: boolean | ImportStringList;
+    /**
+     * Control how your server starts.
+     *
+     * It's built into `dist/server/index.mjs` for production, and it's also run in development if you don't define `+server.js`.
+     *
+     * https://vike.dev/serverEntry
+     */
+    serverEntry?: string | ImportStringList;
     /**
      * Set to `true` to create `.br` and `.gz` files for your static assets at build time, so that they don't have to be compressed on each request.
      *

package/dist/types/GlobalContext.d.ts

@@ -7,12 +7,12 @@ import type { GlobalContextClientInternalWithServerRouting } from '../client/run
 import type { GlobalContextBasePublic } from '../shared-server-client/createGlobalContextShared.js';
 import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
 type GlobalContext = GlobalContextServer | GlobalContextClient;
-type GlobalContextServer = Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'isClientSide'> & {
+type GlobalContextServer = Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'middlewares' | 'isClientSide' | 'devMiddleware'> & {
     /** https://vike.dev/warning/internals */
     dangerouslyUseInternals: GlobalContextServerInternal;
 } & Vike.GlobalContext & Vike.GlobalContextServer;
 type GlobalContextClient = GlobalContextBasePublic & {
     /** https://vike.dev/warning/internals */
     dangerouslyUseInternals: GlobalContextClientInternal;
-} & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
-type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+} & Pick<GlobalContextClientInternal, 'isClientSide' | 'devMiddleware'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide' | 'devMiddleware'> & Vike.GlobalContext & Vike.GlobalContextClient & {};

package/dist/types/PageContext.d.ts

@@ -1,4 +1,3 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
 export type { PageContext };
 export type { PageContextServer };
 export type { PageContextClient };
@@ -8,7 +7,6 @@ export type { PageContextInternalServer };
 export type { PageContextInternalClient };
 export type { PageContextInternalClient_ServerRouting };
 export type { PageContextInternalClient_ClientRouting };
-export type { PageContextInitInternal };
 export type { PageContextInit };
 export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
@@ -149,13 +147,6 @@ type PageContextInit = {
     headersOriginal?: unknown;
     /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
 };
-type PageContextInitInternal = PageContextInit & {
-    _nodeDev?: {
-        req: IncomingMessage;
-        res: ServerResponse;
-    };
-    _reqWeb?: Request;
-};
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextInit & PageContextUrlServer & {
     /**
      * The HTTP request headers.