astro 2.7.4 → 2.8.0

package/dist/@types/astro.d.ts

@@ -784,6 +784,26 @@ export interface AstroUserConfig {
          * ```
          */
         split?: boolean;
+        /**
+         * @docs
+         * @name build.excludeMiddleware
+         * @type {boolean}
+         * @default {false}
+         * @version 2.8.0
+         * @description
+         * Defines whether or not any SSR middleware code will be bundled when built.
+         *
+         * When enabled, middleware code is not bundled and imported by all pages during the build. To instead execute and import middleware code manually, set `build.excludeMiddleware: true`:
+         *
+         * ```js
+         * {
+         *   build: {
+         *     excludeMiddleware: true
+         *   }
+         * }
+         * ```
+         */
+        excludeMiddleware?: boolean;
     };
     /**
      * @docs
@@ -1665,6 +1685,10 @@ export interface AstroIntegration {
              * the physical file you should import.
              */
             entryPoints: Map<RouteData, URL>;
+            /**
+             * File path of the emitted middleware
+             */
+            middlewareEntryPoint: URL | undefined;
         }) => void | Promise<void>;
         'astro:build:start'?: () => void | Promise<void>;
         'astro:build:setup'?: (options: {
@@ -1737,15 +1761,6 @@ export interface SSRElement {
     props: Record<string, any>;
     children: string;
 }
-export interface SSRMetadata {
-    renderers: SSRLoadedRenderer[];
-    pathname: string;
-    hasHydrationScript: boolean;
-    hasDirectives: Set<string>;
-    hasRenderedHead: boolean;
-    headInTree: boolean;
-    clientDirectives: Map<string, string>;
-}
 /**
  * A hint on whether the Astro runtime needs to wait on a component to render head
  * content. The meanings:
@@ -1766,15 +1781,34 @@ export interface SSRResult {
     scripts: Set<SSRElement>;
     links: Set<SSRElement>;
     componentMetadata: Map<string, SSRComponentMetadata>;
-    propagators: Map<AstroComponentFactory, AstroComponentInstance>;
-    extraHead: Array<string>;
-    cookies: AstroCookies | undefined;
     createAstro(Astro: AstroGlobalPartial, props: Record<string, any>, slots: Record<string, any> | null): AstroGlobal;
     resolve: (s: string) => Promise<string>;
     response: ResponseInit;
-    scope: number;
+    renderers: SSRLoadedRenderer[];
+    /**
+     * Map of directive name (e.g. `load`) to the directive script code
+     */
+    clientDirectives: Map<string, string>;
+    compressHTML: boolean;
+    /**
+     * Only used for logging
+     */
+    pathname: string;
+    cookies: AstroCookies | undefined;
     _metadata: SSRMetadata;
 }
+/**
+ * Ephemeral and mutable state during rendering that doesn't rely
+ * on external configuration
+ */
+export interface SSRMetadata {
+    hasHydrationScript: boolean;
+    hasDirectives: Set<string>;
+    hasRenderedHead: boolean;
+    headInTree: boolean;
+    extraHead: string[];
+    propagators: Map<AstroComponentFactory, AstroComponentInstance>;
+}
 export interface PreviewServer {
     host?: string;
     port: number;

package/dist/cli/index.js

@@ -1,5 +1,6 @@
 import fs from "fs";
 import * as colors from "kleur/colors";
+import { arch, platform } from "node:os";
 import yargs from "yargs-parser";
 import { ZodError } from "zod";
 import {
@@ -29,6 +30,7 @@ function printAstroHelp() {
         ["check", "Check your project for errors."],
         ["dev", "Start the development server."],
         ["docs", "Open documentation in your web browser."],
+        ["info", "List info about your current Astro setup."],
         ["preview", "Preview your build locally."],
         ["sync", "Generate content collection types."],
         ["telemetry", "Configure telemetry settings."]
@@ -50,6 +52,48 @@ async function printVersion() {
   console.log();
   console.log(`  ${colors.bgGreen(colors.black(` astro `))} ${colors.green(`v${ASTRO_VERSION}`)}`);
 }
+async function printInfo({
+  cwd,
+  flags,
+  logging
+}) {
+  var _a;
+  const whichPm = await import("which-pm");
+  const packageManager = await whichPm.default(process.cwd());
+  let adapter = "Couldn't determine.";
+  let integrations = [];
+  const MAX_PADDING = 25;
+  function printRow(label, value) {
+    const padding = MAX_PADDING - label.length;
+    console.log(`${colors.bold(label)}` + " ".repeat(padding) + `${colors.green(value)}`);
+  }
+  try {
+    const { userConfig } = await openConfig({
+      cwd,
+      flags,
+      cmd: "info",
+      logging
+    });
+    if ((_a = userConfig.adapter) == null ? void 0 : _a.name) {
+      adapter = userConfig.adapter.name;
+    }
+    if (userConfig.integrations) {
+      integrations = ((userConfig == null ? void 0 : userConfig.integrations) ?? []).filter(Boolean).flat().map((i) => i == null ? void 0 : i.name);
+    }
+  } catch (_e) {
+  }
+  console.log();
+  printRow("Astro version", `v${ASTRO_VERSION}`);
+  printRow("Package manager", packageManager.name);
+  printRow("Platform", platform());
+  printRow("Architecture", arch());
+  printRow("Adapter", adapter);
+  let integrationsString = "None or couldn't determine.";
+  if (integrations.length > 0) {
+    integrationsString = integrations.join(", ");
+  }
+  printRow("Integrations", integrationsString);
+}
 function resolveCommand(flags) {
   const cmd = flags._[2];
   if (flags.version)
@@ -62,7 +106,8 @@ function resolveCommand(flags) {
     "build",
     "preview",
     "check",
-    "docs"
+    "docs",
+    "info"
   ]);
   if (supportedCommands.has(cmd)) {
     return cmd;
@@ -86,6 +131,10 @@ async function handleConfigError(e, { cmd, cwd, flags, logging }) {
 async function runCommand(cmd, flags) {
   var _a;
   const root = flags.root;
+  let logging = {
+    dest: nodeLogDestination,
+    level: "info"
+  };
   switch (cmd) {
     case "help":
       printAstroHelp();
@@ -93,11 +142,11 @@ async function runCommand(cmd, flags) {
     case "version":
       await printVersion();
       return process.exit(0);
+    case "info": {
+      await printInfo({ cwd: root, flags, logging });
+      return process.exit(0);
+    }
   }
-  let logging = {
-    dest: nodeLogDestination,
-    level: "info"
-  };
   if (flags.verbose) {
     logging.level = "debug";
     enableVerboseLogging();

package/dist/core/app/index.js

@@ -44,6 +44,7 @@ class App {
       logging: this.#logging,
       markdown: manifest.markdown,
       mode: "production",
+      compressHTML: manifest.compressHTML,
       renderers: manifest.renderers,
       clientDirectives: manifest.clientDirectives,
       async resolve(specifier) {
@@ -170,7 +171,6 @@ class App {
     const url = new URL(request.url);
     const pathname = prependForwardSlash(this.removeBase(url.pathname));
     const info = this.#routeDataToRouteInfo.get(routeData);
-    const isCompressHTML = this.#manifest.compressHTML ?? false;
     const links = /* @__PURE__ */ new Set();
     const styles = createStylesheetElementSet(info.styles);
     let scripts = /* @__PURE__ */ new Set();
@@ -190,7 +190,6 @@ class App {
       const mod = await page.page();
       const renderContext = await createRenderContext({
         request,
-        origin: url.origin,
         pathname,
         componentMetadata: this.#manifest.componentMetadata,
         scripts,
@@ -219,8 +218,7 @@ class App {
               mod,
               renderContext,
               env: this.#env,
-              cookies: apiContext.cookies,
-              isCompressHTML
+              cookies: apiContext.cookies
             });
           }
         );
@@ -229,8 +227,7 @@ class App {
           mod,
           renderContext,
           env: this.#env,
-          cookies: apiContext.cookies,
-          isCompressHTML
+          cookies: apiContext.cookies
         });
       }
       Reflect.set(request, responseSentSymbol, true);
@@ -250,14 +247,13 @@ class App {
     const handler = mod;
     const ctx = await createRenderContext({
       request,
-      origin: url.origin,
       pathname,
       route: routeData,
       status,
       env: this.#env,
       mod: handler
     });
-    const result = await callEndpoint(handler, this.#env, ctx, this.#logging, page.onRequest);
+    const result = await callEndpoint(handler, this.#env, ctx, page.onRequest);
     if (result.type === "response") {
       if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
         const fourOhFourRequest = new Request(new URL("/404", request.url));

package/dist/core/app/types.d.ts

@@ -30,8 +30,8 @@ export type SSRManifest = {
     adapterName: string;
     routes: RouteInfo[];
     site?: string;
-    base?: string;
-    compressHTML?: boolean;
+    base: string;
+    compressHTML: boolean;
     assetsPrefix?: string;
     markdown: MarkdownRenderingOptions;
     renderers: SSRLoadedRenderer[];

package/dist/core/build/generate.d.ts

@@ -1,7 +1,15 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { AstroSettings } from '../../@types/astro';
+import type { AstroSettings, SSRLoadedRenderer, SSRManifest } from '../../@types/astro';
 import { type BuildInternals } from '../../core/build/internal.js';
 import type { StaticBuildOptions } from './types';
 export declare function rootRelativeFacadeId(facadeId: string, settings: AstroSettings): string;
 export declare function chunkIsPage(settings: AstroSettings, output: OutputAsset | OutputChunk, internals: BuildInternals): boolean;
 export declare function generatePages(opts: StaticBuildOptions, internals: BuildInternals): Promise<void>;
+/**
+ * It creates a `SSRManifest` from the `AstroSettings`.
+ *
+ * Renderers needs to be pulled out from the page module emitted during the build.
+ * @param settings
+ * @param renderers
+ */
+export declare function generateRuntimeManifest(settings: AstroSettings, internals: BuildInternals, renderers: SSRLoadedRenderer[]): SSRManifest;

package/dist/core/build/generate.js

@@ -107,36 +107,35 @@ ${bgGreen(black(` ${verb} static routes `))}`);
           const manifest = ssrEntryPage.manifest;
           const ssrEntry = manifest == null ? void 0 : manifest.pageModule;
           if (ssrEntry) {
-            await generatePage(opts, internals, pageData, ssrEntry, builtPaths);
+            await generatePage(opts, internals, pageData, ssrEntry, builtPaths, manifest);
           } else {
             throw new Error(
               `Unable to find the manifest for the module ${ssrEntryURLPage.toString()}. This is unexpected and likely a bug in Astro, please report.`
             );
           }
         } else {
-          await generatePage(
-            opts,
-            internals,
-            pageData,
-            ssrEntryPage,
-            builtPaths
-          );
+          const ssrEntry = ssrEntryPage;
+          const manifest = generateRuntimeManifest(opts.settings, internals, ssrEntry.renderers);
+          await generatePage(opts, internals, pageData, ssrEntry, builtPaths, manifest);
         }
       }
     }
     for (const pageData of eachRedirectPageData(internals)) {
       const entry = await getEntryForRedirectRoute(pageData.route, internals, outFolder);
-      await generatePage(opts, internals, pageData, entry, builtPaths);
+      const manifest = generateRuntimeManifest(opts.settings, internals, entry.renderers);
+      await generatePage(opts, internals, pageData, entry, builtPaths, manifest);
     }
   } else {
     for (const [pageData, filePath] of eachPageDataFromEntryPoint(internals)) {
       const ssrEntryURLPage = createEntryURL(filePath, outFolder);
-      const ssrEntryPage = await import(ssrEntryURLPage.toString());
-      await generatePage(opts, internals, pageData, ssrEntryPage, builtPaths);
+      const entry = await import(ssrEntryURLPage.toString());
+      const manifest = generateRuntimeManifest(opts.settings, internals, entry.renderers);
+      await generatePage(opts, internals, pageData, entry, builtPaths, manifest);
     }
     for (const pageData of eachRedirectPageData(internals)) {
       const entry = await getEntryForRedirectRoute(pageData.route, internals, outFolder);
-      await generatePage(opts, internals, pageData, entry, builtPaths);
+      const manifest = generateRuntimeManifest(opts.settings, internals, entry.renderers);
+      await generatePage(opts, internals, pageData, entry, builtPaths, manifest);
     }
   }
   if (opts.settings.config.experimental.assets) {
@@ -166,12 +165,11 @@ async function generateImage(opts, transform, path) {
   const statsText = generationData.cached ? `(reused cache entry)` : `(before: ${generationData.weight.before}kb, after: ${generationData.weight.after}kb)`;
   info(opts.logging, null, `  ${green("\u25B6")} ${path} ${dim(statsText)} ${dim(timeIncrease)}`);
 }
-async function generatePage(opts, internals, pageData, ssrEntry, builtPaths) {
+async function generatePage(opts, internals, pageData, ssrEntry, builtPaths, manifest) {
   if (routeIsRedirect(pageData.route) && !opts.settings.config.experimental.redirects) {
     throw new Error(`To use redirects first set experimental.redirects to \`true\``);
   }
   let timeStart = performance.now();
-  const renderers = ssrEntry.renderers;
   const pageInfo = getPageDataByComponent(internals, pageData.route.component);
   const linkIds = [];
   const scripts = (pageInfo == null ? void 0 : pageInfo.hoistedScript) ?? null;
@@ -194,8 +192,7 @@ async function generatePage(opts, internals, pageData, ssrEntry, builtPaths) {
     linkIds,
     scripts,
     styles,
-    mod: pageModule,
-    renderers
+    mod: pageModule
   };
   const icon = pageData.route.type === "page" ? green("\u25B6") : magenta("\u03BB");
   if (isRelativePath(pageData.route.component)) {
@@ -206,7 +203,7 @@ async function generatePage(opts, internals, pageData, ssrEntry, builtPaths) {
   const paths = await getPathsForRoute(pageData, pageModule, opts, builtPaths);
   for (let i = 0; i < paths.length; i++) {
     const path = paths[i];
-    await generatePath(path, opts, generationOptions, onRequest);
+    await generatePath(path, opts, generationOptions, manifest, onRequest);
     const timeEnd = performance.now();
     const timeChange = getTimeStat(timeStart, timeEnd);
     const timeIncrease = `(+${timeChange})`;
@@ -326,9 +323,9 @@ function getUrlForPath(pathname, base, origin, format, routeType) {
   const url = new URL(buildPathname, origin);
   return url;
 }
-async function generatePath(pathname, opts, gopts, onRequest) {
+async function generatePath(pathname, opts, gopts, manifest, onRequest) {
   const { settings, logging, origin, routeCache } = opts;
-  const { mod, internals, scripts: hoistedScripts, styles: _styles, pageData, renderers } = gopts;
+  const { mod, internals, scripts: hoistedScripts, styles: _styles, pageData } = gopts;
   if (pageData.route.type === "page") {
     addPageName(pathname, opts);
   }
@@ -336,24 +333,16 @@ async function generatePath(pathname, opts, gopts, onRequest) {
   const links = /* @__PURE__ */ new Set();
   const scripts = createModuleScriptsSet(
     hoistedScripts ? [hoistedScripts] : [],
-    settings.config.base,
-    settings.config.build.assetsPrefix
-  );
-  const styles = createStylesheetElementSet(
-    _styles,
-    settings.config.base,
-    settings.config.build.assetsPrefix
+    manifest.base,
+    manifest.assetsPrefix
   );
+  const styles = createStylesheetElementSet(_styles, manifest.base, manifest.assetsPrefix);
   if (settings.scripts.some((script) => script.stage === "page")) {
     const hashedFilePath = internals.entrySpecifierToBundleMap.get(PAGE_SCRIPT_ID);
     if (typeof hashedFilePath !== "string") {
       throw new Error(`Cannot find the built path for ${PAGE_SCRIPT_ID}`);
     }
-    const src = createAssetLink(
-      hashedFilePath,
-      settings.config.base,
-      settings.config.build.assetsPrefix
-    );
+    const src = createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
     scripts.add({
       props: { type: "module", src },
       children: ""
@@ -376,12 +365,13 @@ async function generatePath(pathname, opts, gopts, onRequest) {
     pageData.route.type
   );
   const env = createEnvironment({
-    adapterName: void 0,
+    adapterName: manifest.adapterName,
     logging,
-    markdown: settings.config.markdown,
+    markdown: manifest.markdown,
     mode: opts.mode,
-    renderers,
-    clientDirectives: settings.clientDirectives,
+    renderers: manifest.renderers,
+    clientDirectives: manifest.clientDirectives,
+    compressHTML: manifest.compressHTML,
     async resolve(specifier) {
       const hashedFilePath = internals.entrySpecifierToBundleMap.get(specifier);
       if (typeof hashedFilePath !== "string") {
@@ -390,22 +380,17 @@ async function generatePath(pathname, opts, gopts, onRequest) {
         }
         throw new Error(`Cannot find the built path for ${specifier}`);
       }
-      return createAssetLink(
-        hashedFilePath,
-        settings.config.base,
-        settings.config.build.assetsPrefix
-      );
+      return createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
     },
     routeCache,
-    site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : settings.config.site,
+    site: manifest.site,
     ssr,
     streaming: true
   });
   const renderContext = await createRenderContext({
-    origin,
     pathname,
     request: createRequest({ url, headers: new Headers(), logging, ssr }),
-    componentMetadata: internals.componentMetadata,
+    componentMetadata: manifest.componentMetadata,
     scripts,
     styles,
     links,
@@ -421,7 +406,6 @@ async function generatePath(pathname, opts, gopts, onRequest) {
       endpointHandler,
       env,
       renderContext,
-      logging,
       onRequest
     );
     if (result.type === "response") {
@@ -454,7 +438,6 @@ async function generatePath(pathname, opts, gopts, onRequest) {
               mod,
               renderContext,
               env,
-              isCompressHTML: settings.config.compressHTML,
               cookies: apiContext.cookies
             });
           }
@@ -464,7 +447,6 @@ async function generatePath(pathname, opts, gopts, onRequest) {
           mod,
           renderContext,
           env,
-          isCompressHTML: settings.config.compressHTML,
           cookies: apiContext.cookies
         });
       }
@@ -497,8 +479,25 @@ async function generatePath(pathname, opts, gopts, onRequest) {
   await fs.promises.mkdir(outFolder, { recursive: true });
   await fs.promises.writeFile(outFile, body, encoding ?? "utf-8");
 }
+function generateRuntimeManifest(settings, internals, renderers) {
+  return {
+    assets: /* @__PURE__ */ new Set(),
+    entryModules: {},
+    routes: [],
+    adapterName: "",
+    markdown: settings.config.markdown,
+    clientDirectives: settings.clientDirectives,
+    compressHTML: settings.config.compressHTML,
+    renderers,
+    base: settings.config.base,
+    assetsPrefix: settings.config.build.assetsPrefix,
+    site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : settings.config.site,
+    componentMetadata: internals.componentMetadata
+  };
+}
 export {
   chunkIsPage,
   generatePages,
+  generateRuntimeManifest,
   rootRelativeFacadeId
 };

package/dist/core/build/index.d.ts

@@ -1,5 +1,5 @@
-import type { AstroSettings, RuntimeMode } from '../../@types/astro';
 import type yargs from 'yargs-parser';
+import type { AstroSettings, RuntimeMode } from '../../@types/astro';
 import { type LogOptions } from '../logger/core.js';
 export interface BuildOptions {
     mode?: RuntimeMode;

package/dist/core/build/index.js

@@ -8,7 +8,7 @@ import {
   runHookConfigSetup
 } from "../../integrations/index.js";
 import { createVite } from "../create-vite.js";
-import { debug, info, levels, timerMessage } from "../logger/core.js";
+import { debug, info, levels, timerMessage, warn } from "../logger/core.js";
 import { printHelp } from "../messages.js";
 import { apply as applyPolyfill } from "../polyfill.js";
 import { RouteCache } from "../render/route-cache.js";
@@ -158,6 +158,24 @@ class AstroBuilder {
         `the outDir cannot be the root folder. Please build to a folder such as dist.`
       );
     }
+    if (config.build.split === true) {
+      if (config.output === "static") {
+        warn(
+          this.logging,
+          "configuration",
+          'The option `build.split` won\'t take effect, because `output` is not `"server"` or `"hybrid"`.'
+        );
+      }
+    }
+    if (config.build.excludeMiddleware === true) {
+      if (config.output === "static") {
+        warn(
+          this.logging,
+          "configuration",
+          'The option `build.excludeMiddleware` won\'t take effect, because `output` is not `"server"` or `"hybrid"`.'
+        );
+      }
+    }
   }
   /** Stats */
   async printStats({

package/dist/core/build/internal.d.ts

@@ -64,6 +64,7 @@ export interface BuildInternals {
     entryPoints: Map<RouteData, URL>;
     ssrSplitEntryChunks: Map<string, Rollup.OutputChunk>;
     componentMetadata: SSRResult['componentMetadata'];
+    middlewareEntryPoint?: URL;
 }
 /**
  * Creates internal maps used to coordinate the CSS and HTML plugins.

package/dist/core/build/plugins/index.js

@@ -17,7 +17,7 @@ function registerAllPlugins({ internals, options, register }) {
   register(pluginAnalyzer(internals));
   register(pluginInternals(internals));
   register(pluginRenderers(options));
-  register(pluginMiddleware(options));
+  register(pluginMiddleware(options, internals));
   register(pluginPages(options, internals));
   register(pluginCSS(options, internals));
   register(astroHeadBuildPlugin(internals));

package/dist/core/build/plugins/plugin-middleware.d.ts

@@ -1,6 +1,7 @@
 import type { Plugin as VitePlugin } from 'vite';
+import type { BuildInternals } from '../internal';
 import type { AstroBuildPlugin } from '../plugin';
 import type { StaticBuildOptions } from '../types';
 export declare const MIDDLEWARE_MODULE_ID = "@astro-middleware";
-export declare function vitePluginMiddleware(opts: StaticBuildOptions): VitePlugin;
-export declare function pluginMiddleware(opts: StaticBuildOptions): AstroBuildPlugin;
+export declare function vitePluginMiddleware(opts: StaticBuildOptions, internals: BuildInternals): VitePlugin;
+export declare function pluginMiddleware(opts: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

package/dist/core/build/plugins/plugin-middleware.js

@@ -2,7 +2,8 @@ import { MIDDLEWARE_PATH_SEGMENT_NAME } from "../../constants.js";
 import { addRollupInput } from "../add-rollup-input.js";
 const MIDDLEWARE_MODULE_ID = "@astro-middleware";
 const EMPTY_MIDDLEWARE = "\0empty-middleware";
-function vitePluginMiddleware(opts) {
+function vitePluginMiddleware(opts, internals) {
+  let resolvedMiddlewareId;
   return {
     name: "@astro/plugin-middleware",
     options(options) {
@@ -14,6 +15,7 @@ function vitePluginMiddleware(opts) {
           `${opts.settings.config.srcDir.pathname}/${MIDDLEWARE_PATH_SEGMENT_NAME}`
         );
         if (middlewareId) {
+          resolvedMiddlewareId = middlewareId.id;
           return middlewareId.id;
         } else {
           return EMPTY_MIDDLEWARE;
@@ -26,17 +28,34 @@ function vitePluginMiddleware(opts) {
     load(id) {
       if (id === EMPTY_MIDDLEWARE) {
         return "export const onRequest = undefined";
+      } else if (id === resolvedMiddlewareId) {
+        this.emitFile({
+          type: "chunk",
+          preserveSignature: "strict",
+          fileName: "middleware.mjs",
+          id
+        });
+      }
+    },
+    writeBundle(_, bundle) {
+      for (const [chunkName, chunk] of Object.entries(bundle)) {
+        if (chunk.type === "asset") {
+          continue;
+        }
+        if (chunk.fileName === "middleware.mjs") {
+          internals.middlewareEntryPoint = new URL(chunkName, opts.settings.config.build.server);
+        }
       }
     }
   };
 }
-function pluginMiddleware(opts) {
+function pluginMiddleware(opts, internals) {
   return {
     build: "ssr",
     hooks: {
       "build:before": () => {
         return {
-          vitePlugin: vitePluginMiddleware(opts)
+          vitePlugin: vitePluginMiddleware(opts, internals)
         };
       }
     }

package/dist/core/build/plugins/plugin-pages.js

@@ -50,10 +50,12 @@ function vitePluginPages(opts, internals) {
             exports.push(`export { page }`);
             imports.push(`import { renderers } from "${RENDERERS_MODULE_ID}";`);
             exports.push(`export { renderers };`);
-            const middlewareModule = await this.resolve(MIDDLEWARE_MODULE_ID);
-            if (middlewareModule) {
-              imports.push(`import { onRequest } from "${middlewareModule.id}";`);
-              exports.push(`export { onRequest };`);
+            if (!opts.settings.config.build.excludeMiddleware) {
+              const middlewareModule = await this.resolve(MIDDLEWARE_MODULE_ID);
+              if (middlewareModule) {
+                imports.push(`import { onRequest } from "${middlewareModule.id}";`);
+                exports.push(`export { onRequest };`);
+              }
             }
             return `${imports.join("\n")}${exports.join("\n")}`;
           }

package/dist/core/build/plugins/plugin-ssr.js

@@ -108,7 +108,8 @@ function pluginSSR(options, internals) {
           config: options.settings.config,
           manifest,
           logging: options.logging,
-          entryPoints: internals.entryPoints
+          entryPoints: internals.entryPoints,
+          middlewareEntryPoint: internals.middlewareEntryPoint
         });
         const code = injectManifest(manifest, internals.ssrEntryChunk);
         mutate(internals.ssrEntryChunk, "server", code);
@@ -206,7 +207,8 @@ function pluginSSRSplit(options, internals) {
           config: options.settings.config,
           manifest,
           logging: options.logging,
-          entryPoints: internals.entryPoints
+          entryPoints: internals.entryPoints,
+          middlewareEntryPoint: internals.middlewareEntryPoint
         });
         for (const [, chunk] of internals.ssrSplitEntryChunks) {
           const code = injectManifest(manifest, chunk);

package/dist/core/build/static-build.js

@@ -24,7 +24,6 @@ import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
 import { createPluginContainer } from "./plugin.js";
 import { registerAllPlugins } from "./plugins/index.js";
-import { MIDDLEWARE_MODULE_ID } from "./plugins/plugin-middleware.js";
 import { ASTRO_PAGE_RESOLVED_MODULE_ID } from "./plugins/plugin-pages.js";
 import { RESOLVED_RENDERERS_MODULE_ID } from "./plugins/plugin-renderers.js";
 import { RESOLVED_SPLIT_MODULE_ID, SSR_VIRTUAL_MODULE_ID } from "./plugins/plugin-ssr.js";
@@ -141,8 +140,6 @@ async function ssrBuild(opts, internals, input, container) {
               );
             } else if ((_b2 = chunkInfo.facadeModuleId) == null ? void 0 : _b2.startsWith(RESOLVED_SPLIT_MODULE_ID)) {
               return makeSplitEntryPointFileName(chunkInfo.facadeModuleId, routes);
-            } else if (chunkInfo.facadeModuleId === MIDDLEWARE_MODULE_ID) {
-              return "middleware.mjs";
             } else if (chunkInfo.facadeModuleId === SSR_VIRTUAL_MODULE_ID) {
               return opts.settings.config.build.serverEntry;
             } else if (chunkInfo.facadeModuleId === RESOLVED_RENDERERS_MODULE_ID) {