astro 4.10.2 → 4.11.0

package/dist/content/utils.js

@@ -108,6 +108,53 @@ function getEntryConfigByExtMap(entryTypes) {
   }
   return map;
 }
+async function getSymlinkedContentCollections({
+  contentDir,
+  logger,
+  fs
+}) {
+  const contentPaths = /* @__PURE__ */ new Map();
+  const contentDirPath = fileURLToPath(contentDir);
+  try {
+    if (!fs.existsSync(contentDirPath) || !fs.lstatSync(contentDirPath).isDirectory()) {
+      return contentPaths;
+    }
+  } catch {
+    return contentPaths;
+  }
+  try {
+    const contentDirEntries = await fs.promises.readdir(contentDir, { withFileTypes: true });
+    for (const entry of contentDirEntries) {
+      if (entry.isSymbolicLink()) {
+        const entryPath = path.join(contentDirPath, entry.name);
+        const realPath = await fs.promises.realpath(entryPath);
+        contentPaths.set(normalizePath(realPath), entry.name);
+      }
+    }
+  } catch (e) {
+    logger.warn("content", `Error when reading content directory "${contentDir}"`);
+    logger.debug("content", e);
+    return /* @__PURE__ */ new Map();
+  }
+  return contentPaths;
+}
+function reverseSymlink({
+  entry,
+  symlinks,
+  contentDir
+}) {
+  const entryPath = normalizePath(typeof entry === "string" ? entry : fileURLToPath(entry));
+  const contentDirPath = typeof contentDir === "string" ? contentDir : fileURLToPath(contentDir);
+  if (!symlinks || symlinks.size === 0) {
+    return entryPath;
+  }
+  for (const [realPath, symlinkName] of symlinks) {
+    if (entryPath.startsWith(realPath)) {
+      return normalizePath(path.join(contentDirPath, symlinkName, entryPath.replace(realPath, "")));
+    }
+  }
+  return entryPath;
+}
 function getEntryCollectionName({
   contentDir,
   entry
@@ -354,6 +401,7 @@ export {
   getEntrySlug,
   getEntryType,
   getExtGlob,
+  getSymlinkedContentCollections,
   globalContentConfigObserver,
   hasAnyContentFlag,
   hasAssetPropagationFlag,
@@ -363,5 +411,6 @@ export {
   msg,
   parseEntrySlug,
   reloadContentConfigObserver,
+  reverseSymlink,
   safeParseFrontmatter
 };

package/dist/content/vite-plugin-content-imports.d.ts

@@ -2,7 +2,9 @@
 import type fsMod from 'node:fs';
 import type { Plugin } from 'vite';
 import type { AstroSettings } from '../@types/astro.js';
-export declare function astroContentImportPlugin({ fs, settings, }: {
+import type { Logger } from '../core/logger/core.js';
+export declare function astroContentImportPlugin({ fs, settings, logger, }: {
     fs: typeof fsMod;
     settings: AstroSettings;
+    logger: Logger;
 }): Plugin[];

package/dist/content/vite-plugin-content-imports.js

@@ -16,10 +16,12 @@ import {
   getEntryConfigByExtMap,
   getEntryData,
   getEntryType,
+  getSymlinkedContentCollections,
   globalContentConfigObserver,
   hasContentFlag,
   parseEntrySlug,
-  reloadContentConfigObserver
+  reloadContentConfigObserver,
+  reverseSymlink
 } from "./utils.js";
 function getContentRendererByViteId(viteId, settings) {
   let ext = viteId.split(".").pop();
@@ -35,7 +37,8 @@ const CHOKIDAR_MODIFIED_EVENTS = ["add", "unlink", "change"];
 const COLLECTION_TYPES_TO_INVALIDATE_ON = ["data", "content", "config"];
 function astroContentImportPlugin({
   fs,
-  settings
+  settings,
+  logger
 }) {
   const contentPaths = getContentPaths(settings.config, fs);
   const contentEntryExts = getContentEntryExts(settings);
@@ -44,15 +47,23 @@ function astroContentImportPlugin({
   const dataEntryConfigByExt = getEntryConfigByExtMap(settings.dataEntryTypes);
   const { contentDir } = contentPaths;
   let shouldEmitFile = false;
+  let symlinks;
   const plugins = [
     {
       name: "astro:content-imports",
       config(_config, env) {
         shouldEmitFile = env.command === "build";
       },
+      async buildStart() {
+        symlinks = await getSymlinkedContentCollections({ contentDir, logger, fs });
+      },
       async transform(_, viteId) {
         if (hasContentFlag(viteId, DATA_FLAG)) {
-          const fileId = viteId.split("?")[0] ?? viteId;
+          const fileId = reverseSymlink({
+            entry: viteId.split("?")[0] ?? viteId,
+            contentDir,
+            symlinks
+          });
           const { id, data, collection, _internal } = await getDataEntryModule({
             fileId,
             entryConfigByExt: dataEntryConfigByExt,
@@ -74,7 +85,7 @@ export const _internal = {
 `;
           return code;
         } else if (hasContentFlag(viteId, CONTENT_FLAG)) {
-          const fileId = viteId.split("?")[0];
+          const fileId = reverseSymlink({ entry: viteId.split("?")[0], contentDir, symlinks });
           const { id, slug, collection, body, data, _internal } = await getContentEntryModule({
             fileId,
             entryConfigByExt: contentEntryConfigByExt,

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

@@ -39,6 +39,10 @@ export interface RenderErrorOptions {
      * Whether to skip middleware while rendering the error page. Defaults to false.
      */
     skipMiddleware?: boolean;
+    /**
+     * Allows passing an error to 500.astro. It will be available through `Astro.props.error`.
+     */
+    error?: unknown;
 }
 export declare class App {
     #private;

package/dist/core/app/index.js

@@ -195,8 +195,9 @@ class App {
     }
     if (locals) {
       if (typeof locals !== "object") {
-        this.#logger.error(null, new AstroError(AstroErrorData.LocalsNotAnObject).stack);
-        return this.#renderError(request, { status: 500 });
+        const error = new AstroError(AstroErrorData.LocalsNotAnObject);
+        this.#logger.error(null, error.stack);
+        return this.#renderError(request, { status: 500, error });
       }
       Reflect.set(request, clientLocalsSymbol, locals);
     }
@@ -229,13 +230,16 @@ class App {
       response = await renderContext.render(await mod.page());
     } catch (err) {
       this.#logger.error(null, err.stack || err.message || String(err));
-      return this.#renderError(request, { locals, status: 500 });
+      return this.#renderError(request, { locals, status: 500, error: err });
     }
     if (REROUTABLE_STATUS_CODES.includes(response.status) && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
       return this.#renderError(request, {
         locals,
         response,
-        status: response.status
+        status: response.status,
+        // We don't have an error to report here. Passing null means we pass nothing intentionally
+        // while undefined means there's no error
+        error: response.status === 500 ? null : void 0
       });
     }
     if (response.headers.has(REROUTE_DIRECTIVE_HEADER)) {
@@ -276,7 +280,13 @@ class App {
    * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
    * This also handles pre-rendered /404 or /500 routes
    */
-  async #renderError(request, { locals, status, response: originalResponse, skipMiddleware = false }) {
+  async #renderError(request, {
+    locals,
+    status,
+    response: originalResponse,
+    skipMiddleware = false,
+    error
+  }) {
     const errorRoutePath = `/${status}${this.#manifest.trailingSlash === "always" ? "/" : ""}`;
     const errorRouteData = matchRoute(errorRoutePath, this.#manifestData);
     const url = new URL(request.url);
@@ -300,7 +310,8 @@ class App {
           pathname: this.#getPathnameFromRequest(request),
           request,
           routeData: errorRouteData,
-          status
+          status,
+          props: { error }
         });
         const response2 = await renderContext.render(await mod.page());
         return this.#mergeResponses(response2, originalResponse);

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

@@ -7,7 +7,6 @@ export declare class AppPipeline extends Pipeline {
     headElements(routeData: RouteData): Pick<SSRResult, 'scripts' | 'styles' | 'links'>;
     componentMetadata(): void;
     getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
-    tryRewrite(payload: RewritePayload, request: Request, sourceRoute: RouteData): Promise<[RouteData, ComponentInstance, URL]>;
+    tryRewrite(payload: RewritePayload, request: Request, _sourceRoute: RouteData): Promise<[RouteData, ComponentInstance, URL]>;
     getModuleForRoute(route: RouteData): Promise<SinglePageBuiltModule>;
-    rewriteKnownRoute(pathname: string, _sourceRoute: RouteData): ComponentInstance;
 }

package/dist/core/app/pipeline.js

@@ -5,6 +5,7 @@ import { AstroError } from "../errors/index.js";
 import { RedirectSinglePageBuiltModule } from "../redirects/component.js";
 import { createModuleScriptElement, createStylesheetElementSet } from "../render/ssr-element.js";
 import { DEFAULT_404_ROUTE } from "../routing/astro-designed-error-pages.js";
+import { findRouteToRewrite } from "../routing/rewrite.js";
 class AppPipeline extends Pipeline {
   #manifestData;
   static create(manifestData, {
@@ -62,38 +63,17 @@ class AppPipeline extends Pipeline {
     const module = await this.getModuleForRoute(routeData);
     return module.page();
   }
-  async tryRewrite(payload, request, sourceRoute) {
-    let foundRoute;
-    let finalUrl = void 0;
-    for (const route of this.#manifestData.routes) {
-      if (payload instanceof URL) {
-        finalUrl = payload;
-      } else if (payload instanceof Request) {
-        finalUrl = new URL(payload.url);
-      } else {
-        finalUrl = new URL(payload, new URL(request.url).origin);
-      }
-      if (route.pattern.test(decodeURI(finalUrl.pathname))) {
-        foundRoute = route;
-        break;
-      } else if (finalUrl.pathname === "/404") {
-        foundRoute = DEFAULT_404_ROUTE;
-        break;
-      }
-    }
-    if (foundRoute && finalUrl) {
-      if (foundRoute.pathname === "/404") {
-        const componentInstance = this.rewriteKnownRoute(foundRoute.pathname, sourceRoute);
-        return [foundRoute, componentInstance, finalUrl];
-      } else {
-        const componentInstance = await this.getComponentByRoute(foundRoute);
-        return [foundRoute, componentInstance, finalUrl];
-      }
-    }
-    throw new AstroError({
-      ...RewriteEncounteredAnError,
-      message: RewriteEncounteredAnError.message(payload.toString())
+  async tryRewrite(payload, request, _sourceRoute) {
+    const [foundRoute, finalUrl] = findRouteToRewrite({
+      payload,
+      request,
+      routes: this.manifest?.routes.map((r) => r.routeData),
+      trailingSlash: this.manifest.trailingSlash,
+      buildFormat: this.manifest.buildFormat,
+      base: this.manifest.base
     });
+    const componentInstance = await this.getComponentByRoute(foundRoute);
+    return [foundRoute, componentInstance, finalUrl];
   }
   async getModuleForRoute(route) {
     if (route.component === DEFAULT_404_COMPONENT) {
@@ -121,14 +101,6 @@ class AppPipeline extends Pipeline {
       );
     }
   }
-  // We don't need to check the source route, we already are in SSR
-  rewriteKnownRoute(pathname, _sourceRoute) {
-    if (pathname === "/404") {
-      return { default: () => new Response(null, { status: 404 }) };
-    } else {
-      return { default: () => new Response(null, { status: 500 }) };
-    }
-  }
 }
 export {
   AppPipeline

package/dist/core/base-pipeline.d.ts

@@ -73,15 +73,6 @@ export declare abstract class Pipeline {
      * @param routeData
      */
     abstract getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
-    /**
-     * Attempts to execute a rewrite of a known Astro route:
-     * - /404 -> src/pages/404.astro -> template
-     * - /500 -> src/pages/500.astro
-     *
-     * @param pathname The pathname where the user wants to rewrite e.g. "/404"
-     * @param sourceRoute The original route where the first request started. This is needed in case a pipeline wants to check if the current route is pre-rendered or not
-     */
-    abstract rewriteKnownRoute(pathname: string, sourceRoute: RouteData): ComponentInstance;
 }
 export interface HeadElements extends Pick<SSRResult, 'scripts' | 'styles' | 'links'> {
 }

package/dist/core/base-pipeline.js

@@ -30,7 +30,7 @@ class Pipeline {
     if (callSetGetEnv && manifest.experimentalEnvGetSecretEnabled) {
       setGetEnv(() => {
         throw new AstroError(AstroErrorData.EnvUnsupportedGetSecret);
-      });
+      }, true);
     }
   }
   internalMiddleware;

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

@@ -89,6 +89,10 @@ export interface BuildInternals {
     ssrSplitEntryChunks: Map<string, Rollup.OutputChunk>;
     componentMetadata: SSRResult['componentMetadata'];
     middlewareEntryPoint?: URL;
+    /**
+     * Chunks in the bundle that are only used in prerendering that we can delete later
+     */
+    prerenderOnlyChunks: Rollup.OutputChunk[];
 }
 /**
  * Creates internal maps used to coordinate the CSS and HTML plugins.

package/dist/core/build/internal.js

@@ -26,7 +26,8 @@ function createBuildInternals() {
     componentMetadata: /* @__PURE__ */ new Map(),
     ssrSplitEntryChunks: /* @__PURE__ */ new Map(),
     entryPoints: /* @__PURE__ */ new Map(),
-    cacheManifestUsed: false
+    cacheManifestUsed: false,
+    prerenderOnlyChunks: []
   };
 }
 function trackPageData(internals, component, pageData, componentModuleId, componentURL) {

package/dist/core/build/page-data.js

@@ -29,8 +29,7 @@ async function collectPagesData(opts) {
         route,
         moduleSpecifier: "",
         styles: [],
-        hoistedScript: void 0,
-        hasSharedModules: false
+        hoistedScript: void 0
       };
       clearInterval(routeCollectionLogTimeout);
       if (settings.config.output === "static") {
@@ -50,8 +49,7 @@ async function collectPagesData(opts) {
       route,
       moduleSpecifier: "",
       styles: [],
-      hoistedScript: void 0,
-      hasSharedModules: false
+      hoistedScript: void 0
     };
   }
   clearInterval(dataCollectionLogTimeout);

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

@@ -38,7 +38,6 @@ export declare class BuildPipeline extends Pipeline {
      */
     retrieveRoutesToGenerate(): Map<PageBuildData, string>;
     getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
-    tryRewrite(payload: RewritePayload, request: Request, sourceRoute: RouteData): Promise<[RouteData, ComponentInstance, URL]>;
+    tryRewrite(payload: RewritePayload, request: Request, _sourceRoute: RouteData): Promise<[RouteData, ComponentInstance, URL]>;
     retrieveSsrEntry(route: RouteData, filePath: string): Promise<SinglePageBuiltModule>;
-    rewriteKnownRoute(_pathname: string, sourceRoute: RouteData): ComponentInstance;
 }

package/dist/core/build/pipeline.js

@@ -1,7 +1,6 @@
 import { getOutputDirectory } from "../../prerender/utils.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
-import { InvalidRewrite404, RewriteEncounteredAnError } from "../errors/errors-data.js";
-import { AstroError } from "../errors/index.js";
+import { DEFAULT_404_COMPONENT } from "../constants.js";
 import { routeIsFallback, routeIsRedirect } from "../redirects/helpers.js";
 import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
 import { Pipeline } from "../render/index.js";
@@ -10,7 +9,8 @@ import {
   createModuleScriptsSet,
   createStylesheetElementSet
 } from "../render/ssr-element.js";
-import { DEFAULT_404_ROUTE } from "../routing/astro-designed-error-pages.js";
+import { default404Page } from "../routing/astro-designed-error-pages.js";
+import { findRouteToRewrite } from "../routing/rewrite.js";
 import { isServerLikeOutput } from "../util.js";
 import { getOutDirWithinCwd } from "./common.js";
 import { cssOrder, getPageData, mergeInlineCss } from "./internal.js";
@@ -201,45 +201,25 @@ class BuildPipeline extends Pipeline {
     if (this.#componentsInterner.has(routeData)) {
       const entry = this.#componentsInterner.get(routeData);
       return await entry.page();
+    } else if (routeData.component === DEFAULT_404_COMPONENT) {
+      return { default: default404Page };
     } else {
       const filePath = this.#routesByFilePath.get(routeData);
       const module = await this.retrieveSsrEntry(routeData, filePath);
       return module.page();
     }
   }
-  async tryRewrite(payload, request, sourceRoute) {
-    let foundRoute;
-    let finalUrl = void 0;
-    for (const route of this.options.manifest.routes) {
-      if (payload instanceof URL) {
-        finalUrl = payload;
-      } else if (payload instanceof Request) {
-        finalUrl = new URL(payload.url);
-      } else {
-        finalUrl = new URL(payload, new URL(request.url).origin);
-      }
-      if (route.pattern.test(decodeURI(finalUrl.pathname))) {
-        foundRoute = route;
-        break;
-      } else if (finalUrl.pathname === "/404") {
-        foundRoute = DEFAULT_404_ROUTE;
-        break;
-      }
-    }
-    if (foundRoute && finalUrl) {
-      if (foundRoute.pathname === "/404") {
-        const componentInstance = await this.rewriteKnownRoute(foundRoute.pathname, sourceRoute);
-        return [foundRoute, componentInstance, finalUrl];
-      } else {
-        const componentInstance = await this.getComponentByRoute(foundRoute);
-        return [foundRoute, componentInstance, finalUrl];
-      }
-    } else {
-      throw new AstroError({
-        ...RewriteEncounteredAnError,
-        message: RewriteEncounteredAnError.message(payload.toString())
-      });
-    }
+  async tryRewrite(payload, request, _sourceRoute) {
+    const [foundRoute, finalUrl] = findRouteToRewrite({
+      payload,
+      request,
+      routes: this.options.manifest.routes,
+      trailingSlash: this.config.trailingSlash,
+      buildFormat: this.config.build.format,
+      base: this.config.base
+    });
+    const componentInstance = await this.getComponentByRoute(foundRoute);
+    return [foundRoute, componentInstance, finalUrl];
   }
   async retrieveSsrEntry(route, filePath) {
     if (this.#componentsInterner.has(route)) {
@@ -285,12 +265,6 @@ class BuildPipeline extends Pipeline {
     }
     return RedirectSinglePageBuiltModule;
   }
-  rewriteKnownRoute(_pathname, sourceRoute) {
-    if (!isServerLikeOutput(this.config) || sourceRoute.prerender) {
-      throw new AstroError(InvalidRewrite404);
-    }
-    throw new Error(`Unreachable, in SSG this route shouldn't be generated`);
-  }
 }
 function createEntryURL(filePath, outFolder) {
   return new URL("./" + filePath + `?time=${Date.now()}`, outFolder);

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

@@ -8,6 +8,12 @@ function vitePluginChunks() {
           if (id.includes("astro/dist/runtime/server/")) {
             return "astro/server";
           }
+          if (id.includes("astro/dist/runtime")) {
+            return "astro";
+          }
+          if (id.includes("astro/dist/env/setup")) {
+            return "astro/env-setup";
+          }
         }
       });
     }

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

@@ -1,57 +1,64 @@
-import path from "node:path";
 import { getPrerenderMetadata } from "../../../prerender/metadata.js";
-import { extendManualChunks } from "./util.js";
-function vitePluginPrerender(opts, internals) {
+import { ASTRO_PAGE_RESOLVED_MODULE_ID } from "./plugin-pages.js";
+import { getPagesFromVirtualModulePageName } from "./util.js";
+function vitePluginPrerender(internals) {
   return {
     name: "astro:rollup-plugin-prerender",
-    outputOptions(outputOptions) {
-      extendManualChunks(outputOptions, {
-        after(id, meta) {
-          if (id.includes("astro/dist/runtime")) {
-            return "astro";
-          }
-          const pageInfo = internals.pagesByViteID.get(id);
-          let hasSharedModules = false;
-          if (pageInfo) {
-            if (getPrerenderMetadata(meta.getModuleInfo(id))) {
-              const infoMeta = meta.getModuleInfo(id);
-              for (const moduleId of infoMeta.importedIds) {
-                const moduleMeta = meta.getModuleInfo(moduleId);
-                if (
-                  // a shared modules should be inside the `src/` folder, at least
-                  moduleMeta.id.startsWith(opts.settings.config.srcDir.pathname) && // and has at least two importers: the current page and something else
-                  moduleMeta.importers.length > 1
-                ) {
-                  for (const importer of moduleMeta.importedIds) {
-                    if (importer !== id) {
-                      const importerModuleMeta = meta.getModuleInfo(importer);
-                      if (importerModuleMeta) {
-                        if (importerModuleMeta.id.includes("/pages")) {
-                          if (getPrerenderMetadata(importerModuleMeta) === false) {
-                            hasSharedModules = true;
-                            break;
-                          }
-                        } else if (importerModuleMeta.id.includes("/middleware")) {
-                          hasSharedModules = true;
-                          break;
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              pageInfo.hasSharedModules = hasSharedModules;
-              pageInfo.route.prerender = true;
-              return "prerender";
-            }
-            pageInfo.route.prerender = false;
-            return `pages/${path.basename(pageInfo.component)}`;
-          }
-        }
+    generateBundle(_, bundle) {
+      const moduleIds = this.getModuleIds();
+      for (const id of moduleIds) {
+        const pageInfo = internals.pagesByViteID.get(id);
+        if (!pageInfo) continue;
+        const moduleInfo = this.getModuleInfo(id);
+        if (!moduleInfo) continue;
+        const prerender = !!getPrerenderMetadata(moduleInfo);
+        pageInfo.route.prerender = prerender;
+      }
+      const nonPrerenderOnlyChunks = getNonPrerenderOnlyChunks(bundle, internals);
+      internals.prerenderOnlyChunks = Object.values(bundle).filter((chunk) => {
+        return chunk.type === "chunk" && !nonPrerenderOnlyChunks.has(chunk);
       });
     }
   };
 }
+function getNonPrerenderOnlyChunks(bundle, internals) {
+  const chunks = Object.values(bundle);
+  const prerenderOnlyEntryChunks = /* @__PURE__ */ new Set();
+  const nonPrerenderOnlyEntryChunks = /* @__PURE__ */ new Set();
+  for (const chunk of chunks) {
+    if (chunk.type === "chunk" && (chunk.isEntry || chunk.isDynamicEntry)) {
+      if (chunk.facadeModuleId?.startsWith(ASTRO_PAGE_RESOLVED_MODULE_ID)) {
+        const pageDatas = getPagesFromVirtualModulePageName(
+          internals,
+          ASTRO_PAGE_RESOLVED_MODULE_ID,
+          chunk.facadeModuleId
+        );
+        const prerender = pageDatas.every((pageData) => pageData.route.prerender);
+        if (prerender) {
+          prerenderOnlyEntryChunks.add(chunk);
+          continue;
+        }
+      }
+      nonPrerenderOnlyEntryChunks.add(chunk);
+    }
+  }
+  const nonPrerenderOnlyChunks = new Set(nonPrerenderOnlyEntryChunks);
+  for (const chunk of nonPrerenderOnlyChunks) {
+    for (const importFileName of chunk.imports) {
+      const importChunk = bundle[importFileName];
+      if (importChunk?.type === "chunk") {
+        nonPrerenderOnlyChunks.add(importChunk);
+      }
+    }
+    for (const dynamicImportFileName of chunk.dynamicImports) {
+      const dynamicImportChunk = bundle[dynamicImportFileName];
+      if (dynamicImportChunk?.type === "chunk" && !prerenderOnlyEntryChunks.has(dynamicImportChunk)) {
+        nonPrerenderOnlyChunks.add(dynamicImportChunk);
+      }
+    }
+  }
+  return nonPrerenderOnlyChunks;
+}
 function pluginPrerender(opts, internals) {
   if (opts.settings.config.output === "static") {
     return { targets: ["server"] };
@@ -61,7 +68,7 @@ function pluginPrerender(opts, internals) {
     hooks: {
       "build:before": () => {
         return {
-          vitePlugin: vitePluginPrerender(opts, internals)
+          vitePlugin: vitePluginPrerender(internals)
         };
       }
     }

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

@@ -16,7 +16,15 @@ function vitePluginSSR(internals, adapter, options) {
     name: "@astrojs/vite-plugin-astro-ssr-server",
     enforce: "post",
     options(opts) {
-      return addRollupInput(opts, [SSR_VIRTUAL_MODULE_ID]);
+      const inputs = /* @__PURE__ */ new Set();
+      for (const pageData of Object.values(options.allPages)) {
+        if (routeIsRedirect(pageData.route)) {
+          continue;
+        }
+        inputs.add(getVirtualModulePageName(ASTRO_PAGE_MODULE_ID, pageData.component));
+      }
+      inputs.add(SSR_VIRTUAL_MODULE_ID);
+      return addRollupInput(opts, Array.from(inputs));
     },
     resolveId(id) {
       if (id === SSR_VIRTUAL_MODULE_ID) {
@@ -60,7 +68,6 @@ function vitePluginSSR(internals, adapter, options) {
         contents.push(...ssrCode.contents);
         return [...imports, ...contents, ...exports].join("\n");
       }
-      return void 0;
     },
     async generateBundle(_opts, bundle) {
       for (const [, chunk] of Object.entries(bundle)) {
@@ -110,21 +117,18 @@ function pluginSSR(options, internals) {
 const SPLIT_MODULE_ID = "@astro-page-split:";
 const RESOLVED_SPLIT_MODULE_ID = "\0@astro-page-split:";
 function vitePluginSSRSplit(internals, adapter, options) {
-  const functionPerRouteEnabled = isFunctionPerRouteEnabled(options.settings.adapter);
   return {
     name: "@astrojs/vite-plugin-astro-ssr-split",
     enforce: "post",
     options(opts) {
-      if (functionPerRouteEnabled) {
-        const inputs = /* @__PURE__ */ new Set();
-        for (const pageData of Object.values(options.allPages)) {
-          if (routeIsRedirect(pageData.route)) {
-            continue;
-          }
-          inputs.add(getVirtualModulePageName(SPLIT_MODULE_ID, pageData.component));
+      const inputs = /* @__PURE__ */ new Set();
+      for (const pageData of Object.values(options.allPages)) {
+        if (routeIsRedirect(pageData.route)) {
+          continue;
         }
-        return addRollupInput(opts, Array.from(inputs));
+        inputs.add(getVirtualModulePageName(SPLIT_MODULE_ID, pageData.component));
       }
+      return addRollupInput(opts, Array.from(inputs));
     },
     resolveId(id) {
       if (id.startsWith(SPLIT_MODULE_ID)) {
@@ -149,7 +153,6 @@ function vitePluginSSRSplit(internals, adapter, options) {
         exports.push("export { pageModule }");
         return [...imports, ...contents, ...exports].join("\n");
       }
-      return void 0;
     },
     async generateBundle(_opts, bundle) {
       for (const [, chunk] of Object.entries(bundle)) {