vike 0.4.267-commit-feffb0f → 0.4.267-commit-83049a4

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.

package/dist/types/PageContext.js

@@ -1 +1,2 @@
+// Public usage
 export {};

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../../vike-server.d.ts" preserve="true" />
 export type { PageContext, PageContextServer, PageContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, } from './PageContext.js';
 export type { GlobalContext, GlobalContextServer, GlobalContextClient, GlobalContextClientWithServerRouting, } from './GlobalContext.js';
 export type { PrerenderContextPublic as PrerenderContext } from '../node/prerender/runPrerender.js';

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: '0.4.267-commit-feffb0f';
+export declare const PROJECT_VERSION: '0.4.267-commit-83049a4';

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.267-commit-feffb0f';
+export const PROJECT_VERSION = '0.4.267-commit-83049a4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.267-commit-feffb0f",
+  "version": "0.4.267-commit-83049a4",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -87,12 +87,12 @@
       "default": "./dist/shared-server-client/modifyUrl.js"
     },
     "./universal-middleware": {
-      "types": "./dist/server/runtime/universal-middleware.d.ts",
-      "worker": "./dist/server/runtime/universal-middleware.js",
-      "workerd": "./dist/server/runtime/universal-middleware.js",
-      "node": "./dist/server/runtime/universal-middleware.js",
+      "types": "./dist/server/runtime/universal-middleware/deprecated-export.d.ts",
+      "worker": "./dist/server/runtime/universal-middleware/deprecated-export.js",
+      "workerd": "./dist/server/runtime/universal-middleware/deprecated-export.js",
+      "node": "./dist/server/runtime/universal-middleware/deprecated-export.js",
       "browser": "./dist/client/node.js",
-      "default": "./dist/server/runtime/universal-middleware.js"
+      "default": "./dist/server/runtime/universal-middleware/deprecated-export.js"
     },
     "./fetch": {
       "types": "./dist/server/runtime/fetch.d.ts",
@@ -128,15 +128,15 @@
     "@brillout/json-serializer": "^0.5.27",
     "@brillout/picocolors": "^1.0.31",
     "@brillout/vite-plugin-server-entry": "^0.7.23",
-    "@universal-deploy/store": "^0.2.2",
-    "@universal-deploy/vite": "^0.1.14",
-    "@universal-middleware/core": "^0.4.18",
-    "@universal-middleware/node": "^0.2.3",
+    "@universal-deploy/store": "^0.3.0",
+    "@universal-deploy/vite": "^0.2.2",
+    "@universal-middleware/core": "^0.7.0",
+    "@universal-middleware/node": "^0.2.9",
     "cac": "^6.0.0",
-    "convert-route": "^1.1.1",
+    "convert-route": "^2.0.0",
     "es-module-lexer": "^1.0.0",
     "json5": "^2.0.0",
-    "magic-string": "^1.4.2",
+    "magic-string": "^1.4.3",
     "picomatch": "^4.0.7",
     "rolldown": ">=1.0.0",
     "semver": "^7.8.5",
@@ -216,7 +216,7 @@
         "./dist/shared-server-client/modifyUrl.d.ts"
       ],
       "universal-middleware": [
-        "./dist/server/runtime/universal-middleware.d.ts"
+        "./dist/server/runtime/universal-middleware/deprecated-export.d.ts"
       ],
       "fetch": [
         "./dist/server/runtime/fetch.d.ts"
@@ -257,7 +257,8 @@
     "./server.js",
     "./types.js",
     "./universal-middleware.js",
-    "./fetch.js"
+    "./fetch.js",
+    "./vike-server.d.ts"
   ],
   "devDependencies": {
     "@brillout/release-me": "^0.4.19",
@@ -267,7 +268,7 @@
     "@types/picomatch": "^4.0.3",
     "@types/semver": "^7.7.1",
     "@types/source-map-support": "^0.5.10",
-    "react-streaming": "^0.4.20",
+    "react-streaming": "^0.4.21",
     "rimraf": "^6.1.3",
     "typescript": "^7.0.2",
     "vite": "^7.2.6"

package/universal-middleware.js

@@ -1,3 +1,3 @@
 // Some tools still need this as of January 2025
-export * from './dist/server/runtime/universal-middleware.js'
-export { default } from './dist/server/runtime/universal-middleware.js'
+export * from './dist/server/runtime/universal-middleware/deprecated-export.js'
+export { default } from './dist/server/runtime/universal-middleware/deprecated-export.js'

package/vike-server.d.ts

@@ -0,0 +1,14 @@
+// `import server from 'vike:server'` — https://vike.dev/serverEntry
+// Hand-written (not generated by tsc): a .ts file inside this ESM package is always a module, whereas `declare module` below needs a script.
+
+declare module 'vike:server' {
+  /**
+   * Your `+server.js` exports.
+   *
+   * https://vike.dev/serverEntry
+   */
+  const server: Record<string, unknown> & {
+    fetch: (request: Request, ...args: any[]) => Promise<Response>
+  }
+  export default server
+}

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

@@ -1,10 +0,0 @@
-import { type RuntimeAdapterTarget } from '@universal-middleware/core';
-import '../assertEnvServer.js';
-declare function universalVikeHandler<T extends string>(request: Request, context: Universal.Context, runtime: RuntimeAdapterTarget<T>): Promise<Response>;
-declare const universalVikeHandlerEnhanced: typeof universalVikeHandler & import("@universal-middleware/core").WithUniversalSymbols<{
-    name: string;
-    method: ("GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT")[];
-    path: string;
-    immutable: true;
-}>;
-export default universalVikeHandlerEnhanced;

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

@@ -1,27 +0,0 @@
-import { enhance } from '@universal-middleware/core';
-import { renderPageServer } from './renderPageServer.js';
-import '../assertEnvServer.js';
-async function universalVikeHandler(request, context, runtime) {
-    const pageContextInit = {
-        ...context,
-        ...runtime,
-        runtime,
-        urlOriginal: request.url,
-        headersOriginal: request.headers,
-        _reqWeb: request,
-    };
-    const pageContext = await renderPageServer(pageContextInit);
-    const response = pageContext.httpResponse;
-    const readable = response.getReadableWebStream();
-    return new Response(readable, {
-        status: response.statusCode,
-        headers: response.headers,
-    });
-}
-const universalVikeHandlerEnhanced = enhance(universalVikeHandler, {
-    name: 'vike',
-    method: ['GET', 'POST', 'PUT', 'PATCH', 'HEAD', 'OPTIONS'],
-    path: '/**',
-    immutable: true,
-});
-export default universalVikeHandlerEnhanced;