astro 6.0.4 → 6.0.6

package/dist/core/routing/helpers.d.ts

@@ -1,4 +1,5 @@
 import type { RouteData } from '../../types/public/internal.js';
+import type { IntegrationResolvedRoute } from '../../types/public/integrations.js';
 import type { RouteInfo } from '../app/types.js';
 import type { RoutesList } from '../../types/astro.js';
 type RedirectRouteData = RouteData & {
@@ -31,4 +32,16 @@ export declare function getCustom404Route(manifestData: RoutesList): RouteData |
  * Return a user-provided 500 route if one exists.
  */
 export declare function getCustom500Route(manifestData: RoutesList): RouteData | undefined;
+/**
+ * Returns true if the route definition contains `.html` as a static segment part,
+ * as is the case for routes like `[slug].html.astro`. Used to avoid stripping the
+ * `.html` suffix from pathnames that intentionally include it.
+ */
+export declare function routeHasHtmlExtension(route: RouteData): boolean;
+export declare function hasNonPrerenderedProjectRoute(routes: Array<Pick<RouteData, 'type' | 'origin' | 'prerender'>>, options?: {
+    includeEndpoints?: boolean;
+}): boolean;
+export declare function hasNonPrerenderedProjectRoute(routes: Array<Pick<IntegrationResolvedRoute, 'type' | 'origin' | 'isPrerendered'>>, options?: {
+    includeEndpoints?: boolean;
+}): boolean;
 export {};

package/dist/core/routing/helpers.js

@@ -25,10 +25,25 @@ function getCustom404Route(manifestData) {
 function getCustom500Route(manifestData) {
   return manifestData.routes.find((r) => isRoute500(r.route));
 }
+function routeHasHtmlExtension(route) {
+  return route.segments.some(
+    (segment) => segment.some((part) => !part.dynamic && part.content.includes(".html"))
+  );
+}
+function hasNonPrerenderedProjectRoute(routes, options) {
+  const includeEndpoints = options?.includeEndpoints ?? true;
+  const routeTypes = includeEndpoints ? ["page", "endpoint"] : ["page"];
+  return routes.some((route) => {
+    const isPrerendered = "isPrerendered" in route ? route.isPrerendered : route.prerender;
+    return routeTypes.includes(route.type) && route.origin === "project" && !isPrerendered;
+  });
+}
 export {
   getCustom404Route,
   getCustom500Route,
   getFallbackRoute,
+  hasNonPrerenderedProjectRoute,
+  routeHasHtmlExtension,
   routeIsFallback,
   routeIsRedirect
 };

package/dist/core/server-islands/vite-plugin-server-islands.d.ts

@@ -1,5 +1,5 @@
 import type { Plugin as VitePlugin } from 'vite';
 import type { AstroPluginOptions } from '../../types/astro.js';
 export declare const SERVER_ISLAND_MANIFEST = "virtual:astro:server-island-manifest";
-export declare const serverIslandPlaceholderMap = "'$$server-islands-map$$'";
+export declare const SERVER_ISLAND_MAP_MARKER = "$$server-islands-map$$";
 export declare function vitePluginServerIslands({ settings }: AstroPluginOptions): VitePlugin;

package/dist/core/server-islands/vite-plugin-server-islands.js

@@ -1,12 +1,12 @@
-import fs from "node:fs";
-import { getPrerenderOutputDirectory, getServerOutputDirectory } from "../../prerender/utils.js";
-import { AstroError, AstroErrorData } from "../errors/index.js";
-import { appendForwardSlash } from "../path.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
 const SERVER_ISLAND_MANIFEST = "virtual:astro:server-island-manifest";
 const RESOLVED_SERVER_ISLAND_MANIFEST = "\0" + SERVER_ISLAND_MANIFEST;
 const serverIslandPlaceholderMap = "'$$server-islands-map$$'";
 const serverIslandPlaceholderNameMap = "'$$server-islands-name-map$$'";
+const SERVER_ISLAND_MAP_MARKER = "$$server-islands-map$$";
+const serverIslandMapReplaceExp = /['"]\$\$server-islands-map\$\$['"]/g;
+const serverIslandNameMapReplaceExp = /['"]\$\$server-islands-name-map\$\$['"]/g;
 function createServerIslandImportMapSource(entries, toImportPath) {
   const mappings = Array.from(entries, ([islandName, fileName]) => {
     const importPath = toImportPath(fileName);
@@ -22,17 +22,35 @@ function createNameMapSource(entries) {
 function vitePluginServerIslands({ settings }) {
   let command = "serve";
   let ssrEnvironment = null;
-  const referenceIdMap = /* @__PURE__ */ new Map();
   const serverIslandMap = /* @__PURE__ */ new Map();
   const serverIslandNameMap = /* @__PURE__ */ new Map();
-  const resolvedIslandImports = /* @__PURE__ */ new Map();
-  let ssrManifestChunk = null;
+  const serverIslandSourceMap = /* @__PURE__ */ new Map();
+  const referenceIdMap = /* @__PURE__ */ new Map();
+  function ensureServerIslandReferenceIds(ctx) {
+    for (const [resolvedPath, islandName] of serverIslandNameMap) {
+      if (referenceIdMap.has(resolvedPath)) continue;
+      const source = serverIslandSourceMap.get(resolvedPath);
+      const referenceId = ctx.emitFile({
+        type: "chunk",
+        id: source?.id ?? resolvedPath,
+        importer: source?.importer,
+        name: islandName
+      });
+      referenceIdMap.set(resolvedPath, referenceId);
+    }
+  }
   return {
     name: "astro:server-islands",
     enforce: "post",
     config(_config, { command: _command }) {
       command = _command;
     },
+    buildStart() {
+      if (command !== "build" || this.environment?.name !== ASTRO_VITE_ENVIRONMENT_NAMES.ssr) {
+        return;
+      }
+      ensureServerIslandReferenceIds(this);
+    },
     configureServer(server) {
       ssrEnvironment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
     },
@@ -59,16 +77,13 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
     transform: {
       filter: {
         id: {
-          include: [
-            // Allows server islands in astro and mdx files
-            /\.(astro|mdx)$/,
-            new RegExp(`^${RESOLVED_SERVER_ISLAND_MANIFEST}$`)
-          ]
+          include: [/\.(astro|mdx)$/, new RegExp(`^${RESOLVED_SERVER_ISLAND_MANIFEST}$`)]
         }
       },
       async handler(_code, id) {
         const info = this.getModuleInfo(id);
         const astro = info ? info.meta.astro : void 0;
+        const isBuildSsr = command === "build" && this.environment?.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
         if (astro) {
           for (const comp of astro.serverComponents) {
             if (!serverIslandNameMap.has(comp.resolvedPath)) {
@@ -77,23 +92,23 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
               }
               let name = comp.localName;
               let idx = 1;
-              while (true) {
-                if (!serverIslandMap.has(name)) {
-                  break;
-                }
+              while (serverIslandMap.has(name)) {
                 name += idx++;
               }
               serverIslandNameMap.set(comp.resolvedPath, name);
               serverIslandMap.set(name, comp.resolvedPath);
-              if (command === "build") {
-                const referenceId = this.emitFile({
-                  type: "chunk",
-                  id: comp.specifier,
-                  importer: id,
-                  name: comp.localName
-                });
-                referenceIdMap.set(comp.resolvedPath, referenceId);
-              }
+              serverIslandSourceMap.set(comp.resolvedPath, { id: comp.specifier, importer: id });
+            }
+            if (isBuildSsr && !referenceIdMap.has(comp.resolvedPath)) {
+              const islandName = serverIslandNameMap.get(comp.resolvedPath);
+              const source = serverIslandSourceMap.get(comp.resolvedPath);
+              const referenceId = this.emitFile({
+                type: "chunk",
+                id: source?.id ?? comp.resolvedPath,
+                importer: source?.importer,
+                name: islandName
+              });
+              referenceIdMap.set(comp.resolvedPath, referenceId);
             }
           }
         }
@@ -110,7 +125,7 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
               throw new AstroError(AstroErrorData.NoAdapterInstalledServerIslands);
             }
           }
-          if (serverIslandNameMap.size > 0 && serverIslandMap.size > 0) {
+          if (command !== "build" && serverIslandNameMap.size > 0 && serverIslandMap.size > 0) {
             const mapSource = createServerIslandImportMapSource(
               serverIslandMap,
               (fileName) => fileName
@@ -118,22 +133,21 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
             const nameMapSource = createNameMapSource(serverIslandNameMap);
             return {
               code: `
-					export const serverIslandMap = ${mapSource};
-					
+						export const serverIslandMap = ${mapSource};
 
-export const serverIslandNameMap = ${nameMapSource};
-					`
+						export const serverIslandNameMap = ${nameMapSource};
+						`
             };
           }
         }
       }
     },
     renderChunk(code, chunk) {
-      if (code.includes(serverIslandPlaceholderMap)) {
-        if (command === "build") {
-          if (referenceIdMap.size === 0) {
-            return;
-          }
+      if (!code.includes(SERVER_ISLAND_MAP_MARKER)) return;
+      if (command === "build") {
+        const envName = this.environment?.name;
+        let mapSource;
+        if (envName === ASTRO_VITE_ENVIRONMENT_NAMES.ssr) {
           const isRelativeChunk = !chunk.isEntry;
           const dots = isRelativeChunk ? ".." : ".";
           const mapEntries = [];
@@ -141,105 +155,30 @@ export const serverIslandNameMap = ${nameMapSource};
             const fileName = this.getFileName(referenceId);
             const islandName = serverIslandNameMap.get(resolvedPath);
             if (!islandName) continue;
-            if (!resolvedIslandImports.has(islandName)) {
-              resolvedIslandImports.set(islandName, fileName);
-            }
             mapEntries.push([islandName, fileName]);
           }
-          const mapSource = createServerIslandImportMapSource(
+          mapSource = createServerIslandImportMapSource(
             mapEntries,
             (fileName) => `${dots}/${fileName}`
           );
-          const nameMapSource = createNameMapSource(serverIslandNameMap);
-          return {
-            code: code.replace(serverIslandPlaceholderMap, mapSource).replace(serverIslandPlaceholderNameMap, nameMapSource),
-            map: null
-          };
+        } else {
+          mapSource = createServerIslandImportMapSource(serverIslandMap, (fileName) => fileName);
         }
+        const nameMapSource = createNameMapSource(serverIslandNameMap);
         return {
-          code: code.replace(serverIslandPlaceholderMap, "new Map();").replace(serverIslandPlaceholderNameMap, "new Map()"),
+          code: code.replace(serverIslandMapReplaceExp, mapSource).replace(serverIslandNameMapReplaceExp, nameMapSource),
           map: null
         };
       }
-    },
-    generateBundle(_options, bundle) {
-      const envName = this.environment?.name;
-      if (envName === ASTRO_VITE_ENVIRONMENT_NAMES.ssr) {
-        for (const chunk of Object.values(bundle)) {
-          if (chunk.type === "chunk" && chunk.code.includes(serverIslandPlaceholderMap)) {
-            ssrManifestChunk = chunk;
-            break;
-          }
-        }
-      }
-      if (envName === ASTRO_VITE_ENVIRONMENT_NAMES.prerender && ssrManifestChunk) {
-        if (resolvedIslandImports.size > 0) {
-          const isRelativeChunk = ssrManifestChunk.fileName.includes("/");
-          const dots = isRelativeChunk ? ".." : ".";
-          const mapSource = createServerIslandImportMapSource(
-            resolvedIslandImports,
-            (fileName) => `${dots}/${fileName}`
-          );
-          const nameMapSource = createNameMapSource(serverIslandNameMap);
-          ssrManifestChunk.code = ssrManifestChunk.code.replace(serverIslandPlaceholderMap, mapSource).replace(serverIslandPlaceholderNameMap, nameMapSource);
-        } else {
-          ssrManifestChunk.code = ssrManifestChunk.code.replace(serverIslandPlaceholderMap, "new Map()").replace(serverIslandPlaceholderNameMap, "new Map()");
-        }
-      }
-    },
-    api: {
-      /**
-       * Post-build hook that patches SSR chunks containing server island placeholders.
-       *
-       * During build, SSR can run before all server islands are discovered (e.g. islands
-       * only used in prerendered pages). This hook runs after SSR + prerender builds and:
-       * 1) replaces placeholders with the complete map of discovered islands
-       * 2) copies island chunks emitted in prerender into the SSR output directory
-       *
-       * Two cases:
-       * 1. Islands were discovered: Replace placeholders with real import maps.
-       * 2. No islands found: Replace placeholders with empty maps.
-       */
-      async buildPostHook({
-        chunks,
-        mutate
-      }) {
-        const ssrChunkWithPlaceholder = chunks.find(
-          (c) => !c.prerender && c.code.includes(serverIslandPlaceholderMap)
-        );
-        if (!ssrChunkWithPlaceholder) {
-          return;
-        }
-        if (resolvedIslandImports.size > 0) {
-          const isRelativeChunk = ssrChunkWithPlaceholder.fileName.includes("/");
-          const dots = isRelativeChunk ? ".." : ".";
-          const mapSource = createServerIslandImportMapSource(
-            resolvedIslandImports,
-            (fileName) => `${dots}/${fileName}`
-          );
-          const nameMapSource = createNameMapSource(serverIslandNameMap);
-          const newCode = ssrChunkWithPlaceholder.code.replace(serverIslandPlaceholderMap, mapSource).replace(serverIslandPlaceholderNameMap, nameMapSource);
-          mutate(ssrChunkWithPlaceholder.fileName, newCode, false);
-          const serverOutputDir = getServerOutputDirectory(settings);
-          const prerenderOutputDir = getPrerenderOutputDirectory(settings);
-          for (const [, fileName] of resolvedIslandImports) {
-            const srcPath = new URL(fileName, appendForwardSlash(prerenderOutputDir.toString()));
-            const destPath = new URL(fileName, appendForwardSlash(serverOutputDir.toString()));
-            if (!fs.existsSync(srcPath)) continue;
-            const destDir = new URL("./", destPath);
-            await fs.promises.mkdir(destDir, { recursive: true });
-            await fs.promises.copyFile(srcPath, destPath);
-          }
-        } else {
-          const newCode = ssrChunkWithPlaceholder.code.replace(serverIslandPlaceholderMap, "new Map()").replace(serverIslandPlaceholderNameMap, "new Map()");
-          mutate(ssrChunkWithPlaceholder.fileName, newCode, false);
-        }
-      }
+      return {
+        code: code.replace(serverIslandMapReplaceExp, "new Map();").replace(serverIslandNameMapReplaceExp, "new Map()"),
+        map: null
+      };
     }
   };
 }
 export {
   SERVER_ISLAND_MANIFEST,
-  serverIslandPlaceholderMap,
+  SERVER_ISLAND_MAP_MARKER,
   vitePluginServerIslands
 };

package/dist/core/viteUtils.d.ts

@@ -4,7 +4,13 @@ import type { ModuleLoader } from './module-loader/index.js';
  */
 export declare function normalizePath(id: string): string;
 /**
- * Resolve the hydration paths so that it can be imported in the client
+ * Resolve island component specifiers to stable paths for hydration metadata.
+ *
+ * Examples:
+ * - `./components/Button.jsx` from `/app/src/pages/index.astro`
+ *   -> `/app/src/pages/components/Button.tsx` (when `.tsx` exists)
+ * - `#components/react/Counter.tsx`
+ *   -> `/app/src/components/react/Counter.tsx` via package `imports`
  */
 export declare function resolvePath(specifier: string, importer: string): string;
 export declare function rootRelativePath(root: URL, idOrUrl: URL | string, shouldPrependForwardSlash?: boolean): string;

package/dist/core/viteUtils.js

@@ -1,5 +1,6 @@
+import { createRequire } from "node:module";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { prependForwardSlash, slash } from "../core/path.js";
 import { resolveJsToTs, unwrapId, VALID_ID_PREFIX, viteID } from "./util.js";
 const isWindows = typeof process !== "undefined" && process.platform === "win32";
@@ -10,6 +11,22 @@ function resolvePath(specifier, importer) {
   if (specifier.startsWith(".")) {
     const absoluteSpecifier = path.resolve(path.dirname(importer), specifier);
     return resolveJsToTs(normalizePath(absoluteSpecifier));
+  } else if (specifier.startsWith("#")) {
+    try {
+      const resolved = createRequire(pathToFileURL(importer)).resolve(specifier);
+      return resolveJsToTs(normalizePath(resolved));
+    } catch {
+      try {
+        const importerURL = pathToFileURL(importer).toString();
+        const resolved = import.meta.resolve(specifier, importerURL);
+        const resolvedUrl = new URL(resolved);
+        if (resolvedUrl.protocol === "file:") {
+          return resolveJsToTs(normalizePath(fileURLToPath(resolvedUrl)));
+        }
+      } catch {
+      }
+    }
+    return specifier;
   } else {
     return specifier;
   }

package/dist/manifest/serialized.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from 'vite';
+import { type Plugin } from 'vite';
 import type { AstroSettings } from '../types/astro.js';
 export declare const SERIALIZED_MANIFEST_ID = "virtual:astro:manifest";
 export declare const SERIALIZED_MANIFEST_RESOLVED_ID: string;

package/dist/manifest/serialized.js

@@ -1,3 +1,5 @@
+import { fileURLToPath } from "node:url";
+import { normalizePath } from "vite";
 import { ACTIONS_ENTRYPOINT_VIRTUAL_MODULE_ID } from "../actions/consts.js";
 import { toFallbackType } from "../core/app/common.js";
 import { toRoutingStrategy } from "../core/app/entrypoints/index.js";
@@ -31,8 +33,9 @@ function serializedManifestPlugin({
   command,
   sync
 }) {
+  const normalizedSrcDir = normalizePath(fileURLToPath(settings.config.srcDir));
   function reloadManifest(path, server) {
-    if (path != null && path.startsWith(settings.config.srcDir.pathname)) {
+    if (path != null && normalizePath(path).startsWith(normalizedSrcDir)) {
       const environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
       const virtualMod = environment.moduleGraph.getModuleById(SERIALIZED_MANIFEST_RESOLVED_ID);
       if (!virtualMod) return;

package/dist/vite-plugin-astro/hmr.d.ts

@@ -1,10 +1,12 @@
 import type { HmrContext } from 'vite';
 import type { Logger } from '../core/logger/core.js';
+import type { CompileAstroResult } from './compile.js';
 import type { CompileMetadata } from './types.js';
 interface HandleHotUpdateOptions {
     logger: Logger;
+    compile: (code: string, filename: string) => Promise<CompileAstroResult>;
     astroFileToCompileMetadata: Map<string, CompileMetadata>;
 }
-export declare function handleHotUpdate(ctx: HmrContext, { logger, astroFileToCompileMetadata }: HandleHotUpdateOptions): Promise<import("vite").ModuleNode[] | undefined>;
+export declare function handleHotUpdate(ctx: HmrContext, { logger, compile, astroFileToCompileMetadata }: HandleHotUpdateOptions): Promise<import("vite").ModuleNode[] | undefined>;
 export declare function isStyleOnlyChanged(oldCode: string, newCode: string): boolean;
 export {};

package/dist/vite-plugin-astro/hmr.js

@@ -1,6 +1,6 @@
 import { parseAstroRequest } from "./query.js";
 import { frontmatterRE } from "./utils.js";
-async function handleHotUpdate(ctx, { logger, astroFileToCompileMetadata }) {
+async function handleHotUpdate(ctx, { logger, compile, astroFileToCompileMetadata }) {
   for (const [astroFile, compileData] of astroFileToCompileMetadata) {
     const isUpdatedFileCssDep = compileData.css.some((css) => css.dependencies?.includes(ctx.file));
     if (isUpdatedFileCssDep) {
@@ -12,7 +12,11 @@ async function handleHotUpdate(ctx, { logger, astroFileToCompileMetadata }) {
   const newCode = await ctx.read();
   if (isStyleOnlyChanged(oldCode, newCode)) {
     logger.debug("watch", "style-only change");
-    astroFileToCompileMetadata.delete(ctx.file);
+    try {
+      await compile(newCode, ctx.file);
+    } catch {
+      astroFileToCompileMetadata.delete(ctx.file);
+    }
     return ctx.modules.filter((mod) => {
       if (!mod.id) {
         return false;

package/dist/vite-plugin-astro/index.js

@@ -246,7 +246,7 @@ File: ${id}`
         }
       },
       async handleHotUpdate(ctx) {
-        return handleHotUpdate(ctx, { logger, astroFileToCompileMetadata });
+        return handleHotUpdate(ctx, { logger, compile, astroFileToCompileMetadata });
       }
     },
     {

package/dist/vite-plugin-astro-server/plugin.js

@@ -19,7 +19,7 @@ import { getViteErrorPayload } from "../core/errors/dev/index.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
 import { createViteLoader } from "../core/module-loader/index.js";
-import { matchAllRoutes } from "../core/routing/match.js";
+import { isRouteServerIsland, matchAllRoutes } from "../core/routing/match.js";
 import { resolveMiddlewareMode } from "../integrations/adapter-utils.js";
 import { SERIALIZED_MANIFEST_ID } from "../manifest/serialized.js";
 import { ASTRO_DEV_SERVER_APP_ID } from "../vite-plugin-app/index.js";
@@ -45,9 +45,6 @@ function createVitePluginAstroServer({
       const prerenderEnvironment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.prerender];
       const runnableSsrEnvironment = isRunnableDevEnvironment(ssrEnvironment) ? ssrEnvironment : void 0;
       const runnablePrerenderEnvironment = isRunnableDevEnvironment(prerenderEnvironment) ? prerenderEnvironment : void 0;
-      if (!runnableSsrEnvironment && !runnablePrerenderEnvironment) {
-        return;
-      }
       async function createHandler(environment) {
         const loader = createViteLoader(viteServer, environment);
         const { default: createAstroServerApp } = await environment.runner.import(ASTRO_DEV_SERVER_APP_ID);
@@ -84,17 +81,16 @@ function createVitePluginAstroServer({
           );
         }
       }
-      process.on("unhandledRejection", handleUnhandledRejection);
-      viteServer.httpServer?.on("close", () => {
-        process.off("unhandledRejection", handleUnhandledRejection);
-      });
+      if (ssrHandler || prerenderHandler) {
+        process.on("unhandledRejection", handleUnhandledRejection);
+        viteServer.httpServer?.on("close", () => {
+          process.off("unhandledRejection", handleUnhandledRejection);
+        });
+      }
       return () => {
         const shouldHandlePrerenderInCore = Boolean(
           viteServer[devPrerenderMiddlewareSymbol]
         );
-        if (!ssrHandler && !(prerenderHandler && shouldHandlePrerenderInCore)) {
-          return;
-        }
         viteServer.middlewares.stack.unshift({
           route: "",
           handle: baseMiddleware(settings, logger)
@@ -130,7 +126,7 @@ function createVitePluginAstroServer({
                 const { routes } = await prerenderHandler.environment.runner.import("virtual:astro:routes");
                 const routesList = { routes: routes.map((r) => r.routeData) };
                 const matches = matchAllRoutes(pathname, routesList);
-                if (!matches.some((route) => route.prerender)) {
+                if (!matches.some((route) => route.prerender || isRouteServerIsland(route))) {
                   return next();
                 }
                 localStorage.run(request, () => {

package/dist/vite-plugin-renderers/index.js

@@ -1,11 +1,7 @@
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+import { hasNonPrerenderedProjectRoute } from "../core/routing/helpers.js";
 const ASTRO_RENDERERS_MODULE_ID = "virtual:astro:renderers";
 const RESOLVED_ASTRO_RENDERERS_MODULE_ID = `\0${ASTRO_RENDERERS_MODULE_ID}`;
-function ssrBuildNeedsRenderers(routesList) {
-  return routesList.routes.some(
-    (route) => route.type === "page" && !route.prerender && route.origin !== "internal"
-  );
-}
 function vitePluginRenderers(options) {
   const renderers = options.settings.renderers;
   return {
@@ -24,7 +20,9 @@ function vitePluginRenderers(options) {
         id: new RegExp(`^${RESOLVED_ASTRO_RENDERERS_MODULE_ID}$`)
       },
       handler() {
-        if (options.command === "build" && this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr && renderers.length > 0 && !ssrBuildNeedsRenderers(options.routesList)) {
+        if (options.command === "build" && this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr && renderers.length > 0 && !hasNonPrerenderedProjectRoute(options.routesList.routes, {
+          includeEndpoints: false
+        })) {
           return { code: `export const renderers = [];` };
         }
         if (renderers.length > 0) {

package/dist/vite-plugin-routes/index.js

@@ -52,11 +52,12 @@ async function astroPluginRoutes({
       };
     }
   );
+  const normalizedSrcDir = normalizePath(fileURLToPath(settings.config.srcDir));
   async function rebuildRoutes(path = null, server) {
-    if (path != null && path.startsWith(settings.config.srcDir.pathname)) {
+    if (path != null && normalizePath(path).startsWith(normalizedSrcDir)) {
       logger.debug(
         "update",
-        `Re-calculating routes for ${path.slice(settings.config.srcDir.pathname.length)}`
+        `Re-calculating routes for ${normalizePath(path).slice(normalizedSrcDir.length)}`
       );
       const file = pathToFileURL(normalizePath(path));
       const newRoutesList = await createRoutesList(

package/dist/vite-plugin-scripts/index.js

@@ -38,7 +38,7 @@ function astroScriptsPlugin({ settings }) {
     },
     buildStart() {
       const hasHydrationScripts = settings.scripts.some((s) => s.stage === "before-hydration");
-      if (hasHydrationScripts && (this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender || this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr)) {
+      if (hasHydrationScripts && (this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender || this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr)) {
         this.emitFile({
           type: "chunk",
           id: BEFORE_HYDRATION_SCRIPT_ID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.0.4",
+  "version": "6.0.6",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -154,7 +154,7 @@
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6",
     "@astrojs/internal-helpers": "0.8.0",
-    "@astrojs/markdown-remark": "7.0.0",
+    "@astrojs/markdown-remark": "7.0.1",
     "@astrojs/telemetry": "3.3.0"
   },
   "optionalDependencies": {
@@ -190,11 +190,11 @@
     "undici": "^7.22.0",
     "unified": "^11.0.5",
     "vitest": "^3.2.4",
-    "@astrojs/check": "0.9.7",
+    "@astrojs/check": "0.9.8",
     "astro-scripts": "0.0.14"
   },
   "engines": {
-    "node": "^20.19.1 || >=22.12.0",
+    "node": ">=22.12.0",
     "npm": ">=9.6.5",
     "pnpm": ">=7.1.0"
   },

package/templates/content/types.d.ts

@@ -111,11 +111,12 @@ declare module 'astro:content' {
 	type InferEntrySchema<C extends keyof DataEntryMap> = import('astro/zod').infer<
 		ReturnTypeOrOriginal<Required<ContentConfig['collections'][C]>['schema']>
 	>;
+	type ExtractLoaderConfig<T> = T extends { loader: infer L } ? L : never;
 	type InferLoaderSchema<
 		C extends keyof DataEntryMap,
-		L = Required<ContentConfig['collections'][C]>['loader'],
+		L = ExtractLoaderConfig<ContentConfig['collections'][C]>,
 	> = L extends { schema: import('astro/zod').ZodSchema }
-		? import('astro/zod').infer<Required<ContentConfig['collections'][C]>['loader']['schema']>
+		? import('astro/zod').infer<L['schema']>
 		: any;
 
 	type DataEntryMap = {