astro 6.0.5 → 6.0.7

package/bin/astro.mjs

@@ -8,12 +8,9 @@ const CI_INSTRUCTIONS = {
 	VERCEL: 'https://vercel.com/docs/runtimes#official-runtimes/node-js/node-js-version',
 };
 
-// TODO: remove once Stackblitz supports Node 22
-const IS_STACKBLITZ = !!process.versions.webcontainer;
-
 // Hardcode supported Node.js version so we don't have to read differently in CJS & ESM.
-const engines = IS_STACKBLITZ ? '>=20.19.1' : '>=22.12.0';
-const skipSemverCheckIfAbove = IS_STACKBLITZ ? 21 : 23;
+const engines = '>=22.12.0';
+const skipSemverCheckIfAbove = 23;
 
 /** `astro *` */
 async function main() {

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "6.0.5";
+  version = "6.0.7";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

@@ -117,7 +117,10 @@ class ContentLayer {
     });
     return {
       html: code,
-      metadata
+      metadata: {
+        ...metadata,
+        imagePaths: (metadata.localImagePaths ?? []).concat(metadata.remoteImagePaths ?? [])
+      }
     };
   }
   /**
@@ -189,7 +192,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.0.5") {
+    if (previousAstroVersion && previousAstroVersion !== "6.0.7") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -197,8 +200,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.0.5") {
-      this.#store.metaStore().set("astro-version", "6.0.5");
+    if ("6.0.7") {
+      this.#store.metaStore().set("astro-version", "6.0.7");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/core/app/base.js

@@ -32,6 +32,7 @@ import { AstroIntegrationLogger, Logger } from "../logger/core.js";
 import { RenderContext } from "../render-context.js";
 import { redirectTemplate } from "../routing/3xx.js";
 import { ensure404Route } from "../routing/astro-designed-error-pages.js";
+import { routeHasHtmlExtension } from "../routing/helpers.js";
 import { matchRoute } from "../routing/match.js";
 import { applyCacheHeaders } from "../cache/runtime/cache.js";
 import { Router } from "../routing/router.js";
@@ -303,7 +304,7 @@ class BaseApp {
       });
     }
     let pathname = this.getPathnameFromRequest(request);
-    if (this.isDev()) {
+    if (this.isDev() && !routeHasHtmlExtension(routeData)) {
       pathname = pathname.replace(/\/index\.html$/, "/").replace(/\.html$/, "");
     }
     const defaultStatus = this.getDefaultStatusCode(routeData, pathname);

package/dist/core/app/entrypoints/node.d.ts

@@ -1 +1 @@
-export { NodeApp, loadApp, loadManifest, createRequest, writeResponse } from '../node.js';
+export { NodeApp, loadApp, loadManifest, createRequest, writeResponse, getAbortControllerCleanup, } from '../node.js';

package/dist/core/app/entrypoints/node.js

@@ -1,7 +1,15 @@
-import { NodeApp, loadApp, loadManifest, createRequest, writeResponse } from "../node.js";
+import {
+  NodeApp,
+  loadApp,
+  loadManifest,
+  createRequest,
+  writeResponse,
+  getAbortControllerCleanup
+} from "../node.js";
 export {
   NodeApp,
   createRequest,
+  getAbortControllerCleanup,
   loadApp,
   loadManifest,
   writeResponse

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

@@ -5,3 +5,4 @@ import type { MiddlewareHandler } from '../../types/public/common.js';
  * @private
  */
 export declare function createOriginCheckMiddleware(): MiddlewareHandler;
+export declare function hasFormLikeHeader(contentType: string | null): boolean;

package/dist/core/app/middlewares.js

@@ -44,5 +44,6 @@ function hasFormLikeHeader(contentType) {
   return false;
 }
 export {
-  createOriginCheckMiddleware
+  createOriginCheckMiddleware,
+  hasFormLikeHeader
 };

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

@@ -90,6 +90,23 @@ export declare class NodeApp extends App {
      */
     static writeResponse: typeof writeResponse;
 }
+/**
+ * Returns the cleanup function for the AbortController and socket listeners created by `createRequest()`
+ * for the NodeJS IncomingMessage. This should only be called directly if the request is not
+ * being handled by Astro, i.e. if not calling `writeResponse()` after `createRequest()`.
+ * ```js
+ * import { createRequest, getAbortControllerCleanup } from 'astro/app/node';
+ * import { createServer } from 'node:http';
+ *
+ * const server = createServer(async (req, res) => {
+ *     const request = createRequest(req);
+ *     const cleanup = getAbortControllerCleanup(req);
+ *     if (cleanup) cleanup();
+ *     // can now safely call another handler
+ * })
+ * ```
+ */
+export declare function getAbortControllerCleanup(req?: NodeRequest): (() => void) | undefined;
 /** @deprecated This will be removed in a future major version. */
 export declare function loadManifest(rootFolder: URL): Promise<SSRManifest>;
 /** @deprecated This will be removed in a future major version. */

package/dist/core/app/node.js

@@ -278,6 +278,7 @@ async function loadApp(rootFolder) {
 export {
   NodeApp,
   createRequest,
+  getAbortControllerCleanup,
   loadApp,
   loadManifest,
   writeResponse

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

@@ -81,13 +81,19 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
   const { settings } = opts;
   const routes = [];
   const domainLookupTable = {};
-  const entryModules = Object.fromEntries(internals.entrySpecifierToBundleMap.entries());
-  if (settings.scripts.some((script) => script.stage === "page")) {
-    staticFiles.push(entryModules[PAGE_SCRIPT_ID]);
-  }
+  const rawEntryModules = Object.fromEntries(internals.entrySpecifierToBundleMap.entries());
   const assetQueryParams = settings.adapter?.client?.assetQueryParams;
   const assetQueryString = assetQueryParams ? assetQueryParams.toString() : void 0;
   const appendAssetQuery = (pth) => assetQueryString ? `${pth}?${assetQueryString}` : pth;
+  const entryModules = Object.fromEntries(
+    Object.entries(rawEntryModules).map(([key, value]) => [
+      key,
+      value ? appendAssetQuery(value) : value
+    ])
+  );
+  if (settings.scripts.some((script) => script.stage === "page")) {
+    staticFiles.push(rawEntryModules[PAGE_SCRIPT_ID]);
+  }
   const prefixAssetPath = (pth) => {
     let result = "";
     if (settings.config.build.assetsPrefix) {
@@ -118,7 +124,7 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
     if (!pageData) continue;
     const scripts = [];
     if (settings.scripts.some((script) => script.stage === "page")) {
-      const src = entryModules[PAGE_SCRIPT_ID];
+      const src = rawEntryModules[PAGE_SCRIPT_ID];
       scripts.push({
         type: "external",
         value: appendAssetQuery(src)

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.0.5";
+const ASTRO_VERSION = "6.0.7";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";

package/dist/core/create-vite.js

@@ -43,6 +43,7 @@ import astroScriptsPageSSRPlugin from "../vite-plugin-scripts/page-ssr.js";
 import { createViteLogger } from "./logger/vite.js";
 import { vitePluginMiddleware } from "./middleware/vite-plugin.js";
 import { joinPaths } from "./path.js";
+import { ServerIslandsState } from "./server-islands/shared-state.js";
 import { vitePluginServerIslands } from "./server-islands/vite-plugin-server-islands.js";
 import { vitePluginCacheProvider } from "./cache/vite-plugin.js";
 import { vitePluginSessionDriver } from "./session/vite-plugin.js";
@@ -80,6 +81,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
     mode,
     config: settings.config
   });
+  const serverIslandsState = new ServerIslandsState();
   validateEnvPrefixAgainstSchema(settings.config);
   const commonConfig = {
     // Tell Vite not to combine config from vite.config.js with our provided inline config
@@ -96,6 +98,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       vitePluginRenderers({
         settings,
         routesList,
+        serverIslandsState,
         command: command === "dev" ? "serve" : "build"
       }),
       vitePluginStaticPaths(),
@@ -133,7 +136,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       vitePluginFileURL(),
       astroInternationalization({ settings }),
       vitePluginActions({ fs, settings }),
-      vitePluginServerIslands({ settings, logger }),
+      vitePluginServerIslands({ settings, logger, serverIslandsState }),
       vitePluginSessionDriver({ settings }),
       vitePluginCacheProvider({ settings }),
       astroContainer(),

package/dist/core/dev/dev.js

@@ -26,7 +26,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "6.0.5";
+  const currentVersion = "6.0.7";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages/runtime.js

@@ -269,7 +269,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.0.5"}`
+        `v${"6.0.7"}`
       )} ${headline}`
     );
   }

package/dist/core/render/params-and-props.js

@@ -1,6 +1,6 @@
 import { DEFAULT_404_COMPONENT } from "../constants.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
-import { routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
+import { routeHasHtmlExtension, routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
 import { callGetStaticPaths, findPathItemByKey } from "./route-cache.js";
 async function getProps(opts) {
   const {
@@ -44,11 +44,9 @@ async function getProps(opts) {
 }
 function getParams(route, pathname) {
   if (!route.params.length) return {};
-  let path = pathname;
-  if (pathname.endsWith(".html")) {
-    path = path.slice(0, -5);
-  }
-  const paramsMatch = route.pattern.exec(path) || route.fallbackRoutes.map((fallbackRoute) => fallbackRoute.pattern.exec(path)).find((x) => x);
+  const path = pathname.endsWith(".html") && !routeHasHtmlExtension(route) ? pathname.slice(0, -5) : pathname;
+  const allPatterns = [route, ...route.fallbackRoutes].map((r) => r.pattern);
+  const paramsMatch = allPatterns.map((pattern) => pattern.exec(path)).find((x) => x);
   if (!paramsMatch) return {};
   const params = {};
   route.params.forEach((key, i) => {

package/dist/core/render/ssr-element.js

@@ -1,17 +1,39 @@
 import { getAssetsPrefix } from "../../assets/utils/getAssetsPrefix.js";
 import { fileExtension, joinPaths, prependForwardSlash, slash } from "../../core/path.js";
+const URL_PARSE_BASE = "https://astro.build";
+function splitAssetPath(path) {
+  const parsed = new URL(path, URL_PARSE_BASE);
+  const isAbsolute = URL.canParse(path);
+  const pathname = !isAbsolute && !path.startsWith("/") ? parsed.pathname.slice(1) : parsed.pathname;
+  return {
+    pathname,
+    suffix: `${parsed.search}${parsed.hash}`
+  };
+}
+function appendQueryParams(path, queryParams) {
+  const queryString = queryParams.toString();
+  if (!queryString) {
+    return path;
+  }
+  const hashIndex = path.indexOf("#");
+  const basePath = hashIndex === -1 ? path : path.slice(0, hashIndex);
+  const hash = hashIndex === -1 ? "" : path.slice(hashIndex);
+  const separator = basePath.includes("?") ? "&" : "?";
+  return `${basePath}${separator}${queryString}${hash}`;
+}
 function createAssetLink(href, base, assetsPrefix, queryParams) {
+  const { pathname, suffix } = splitAssetPath(href);
   let url = "";
   if (assetsPrefix) {
-    const pf = getAssetsPrefix(fileExtension(href), assetsPrefix);
-    url = joinPaths(pf, slash(href));
+    const pf = getAssetsPrefix(fileExtension(pathname), assetsPrefix);
+    url = joinPaths(pf, slash(pathname)) + suffix;
   } else if (base) {
-    url = prependForwardSlash(joinPaths(base, slash(href)));
+    url = prependForwardSlash(joinPaths(base, slash(pathname))) + suffix;
   } else {
     url = href;
   }
   if (queryParams) {
-    url += "?" + queryParams.toString();
+    url = appendQueryParams(url, queryParams);
   }
   return url;
 }

package/dist/core/render-context.js

@@ -4,6 +4,7 @@ import { getActionContext } from "../actions/runtime/server.js";
 import { createCallAction, createGetActionResult, hasActionPayload } from "../actions/utils.js";
 import {
   computeCurrentLocale,
+  computeCurrentLocaleFromParams,
   computePreferredLocale,
   computePreferredLocaleList
 } from "../i18n/utils.js";
@@ -737,6 +738,12 @@ class RenderContext {
       }
       pathname = pathname && !isRoute404or500(routeData) ? pathname : url.pathname;
       computedLocale = computeCurrentLocale(pathname, locales, defaultLocale);
+      if (routeData.params.length > 0) {
+        const localeFromParams = computeCurrentLocaleFromParams(this.params, locales);
+        if (localeFromParams) {
+          computedLocale = localeFromParams;
+        }
+      }
     }
     this.#currentLocale = computedLocale ?? fallbackTo;
     return this.#currentLocale;

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

@@ -32,6 +32,12 @@ 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;

package/dist/core/routing/helpers.js

@@ -25,6 +25,11 @@ 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"];
@@ -38,6 +43,7 @@ export {
   getCustom500Route,
   getFallbackRoute,
   hasNonPrerenderedProjectRoute,
+  routeHasHtmlExtension,
   routeIsFallback,
   routeIsRedirect
 };

package/dist/core/routing/match.js

@@ -2,6 +2,14 @@ import { redirectIsExternal } from "../redirects/render.js";
 import { SERVER_ISLAND_COMPONENT } from "../server-islands/endpoint.js";
 import { isRoute404, isRoute500 } from "./internal/route-errors.js";
 function matchRoute(pathname, manifest) {
+  if (isRoute404(pathname)) {
+    const errorRoute = manifest.routes.find((route) => isRoute404(route.route));
+    if (errorRoute) return errorRoute;
+  }
+  if (isRoute500(pathname)) {
+    const errorRoute = manifest.routes.find((route) => isRoute500(route.route));
+    if (errorRoute) return errorRoute;
+  }
   return manifest.routes.find((route) => {
     return route.pattern.test(pathname) || route.fallbackRoutes.some((fallbackRoute) => fallbackRoute.pattern.test(pathname));
   });

package/dist/core/routing/rewrite.js

@@ -10,6 +10,7 @@ import {
 } from "../path.js";
 import { createRequest } from "../request.js";
 import { DEFAULT_404_ROUTE } from "./internal/astro-designed-error-pages.js";
+import { isRoute404, isRoute500 } from "./internal/route-errors.js";
 function findRouteToRewrite({
   payload,
   routes,
@@ -53,6 +54,18 @@ function findRouteToRewrite({
     newUrl.pathname = joinPaths(...[base, pathname].filter(Boolean));
   }
   const decodedPathname = decodeURI(pathname);
+  if (isRoute404(decodedPathname)) {
+    const errorRoute = routes.find((route) => route.route === "/404");
+    if (errorRoute) {
+      return { routeData: errorRoute, newUrl, pathname: decodedPathname };
+    }
+  }
+  if (isRoute500(decodedPathname)) {
+    const errorRoute = routes.find((route) => route.route === "/500");
+    if (errorRoute) {
+      return { routeData: errorRoute, newUrl, pathname: decodedPathname };
+    }
+  }
   let foundRoute;
   for (const route of routes) {
     if (route.pattern.test(decodedPathname)) {

package/dist/core/server-islands/shared-state.d.ts

@@ -0,0 +1,44 @@
+type ServerIslandDiscovery = {
+    resolvedPath: string;
+    localName: string;
+    specifier: string;
+    importer: string;
+};
+type ServerIslandRecord = Omit<ServerIslandDiscovery, 'resolvedPath'> & {
+    islandName: string;
+};
+export declare class ServerIslandsState {
+    private islandsByResolvedPath;
+    private resolvedPathByIslandName;
+    private referenceIdByResolvedPath;
+    hasIslands(): boolean;
+    /**
+     * Record a discovered server island.
+     *
+     * Dedupe is based on `resolvedPath`: if the same resolved path is discovered
+     * again from a different importer/specifier, the first record is preserved.
+     * This keeps island names stable across repeated scans.
+     */
+    discover(island: ServerIslandDiscovery): ServerIslandRecord;
+    getDiscoveredIslands(): Iterable<ServerIslandRecord>;
+    hasReferenceId(resolvedPath: string): boolean;
+    setReferenceId(resolvedPath: string, referenceId: string): void;
+    getDiscoveredIslandEntries(): Iterable<[string, ServerIslandRecord]>;
+    /**
+     * Build import-map source from discovered islands.
+     *
+     * Used by non-SSR build output and dev replacement paths where we can import
+     * directly from discovered component paths.
+     */
+    createImportMapSourceFromDiscovered(toImportPath: (fileName: string) => string): string;
+    /**
+     * Build import-map source from Rollup reference ids.
+     *
+     * Used by SSR build output: reference ids are resolved to final emitted chunk
+     * file names before generating import() mappings.
+     */
+    createImportMapSourceFromReferences(resolveFileName: (referenceId: string) => string, toImportPath: (fileName: string) => string): string;
+    createNameMapSource(): string;
+    private createImportMapSource;
+}
+export {};

package/dist/core/server-islands/shared-state.js

@@ -0,0 +1,96 @@
+class ServerIslandsState {
+  // Canonical source of discovered islands keyed by resolved component path.
+  islandsByResolvedPath = /* @__PURE__ */ new Map();
+  // Reverse lookup used to keep island names unique and stable.
+  resolvedPathByIslandName = /* @__PURE__ */ new Map();
+  // Rollup reference ids emitted for SSR chunks, keyed by resolved path.
+  referenceIdByResolvedPath = /* @__PURE__ */ new Map();
+  hasIslands() {
+    return this.islandsByResolvedPath.size > 0;
+  }
+  /**
+   * Record a discovered server island.
+   *
+   * Dedupe is based on `resolvedPath`: if the same resolved path is discovered
+   * again from a different importer/specifier, the first record is preserved.
+   * This keeps island names stable across repeated scans.
+   */
+  discover(island) {
+    const { resolvedPath, ...discovery } = island;
+    const existing = this.islandsByResolvedPath.get(resolvedPath);
+    if (existing) {
+      return existing;
+    }
+    let name = island.localName;
+    let idx = 1;
+    while (this.resolvedPathByIslandName.has(name)) {
+      name += idx++;
+    }
+    const record = {
+      ...discovery,
+      islandName: name
+    };
+    this.islandsByResolvedPath.set(resolvedPath, record);
+    this.resolvedPathByIslandName.set(name, resolvedPath);
+    return record;
+  }
+  getDiscoveredIslands() {
+    return this.islandsByResolvedPath.values();
+  }
+  hasReferenceId(resolvedPath) {
+    return this.referenceIdByResolvedPath.has(resolvedPath);
+  }
+  setReferenceId(resolvedPath, referenceId) {
+    this.referenceIdByResolvedPath.set(resolvedPath, referenceId);
+  }
+  getDiscoveredIslandEntries() {
+    return this.islandsByResolvedPath.entries();
+  }
+  /**
+   * Build import-map source from discovered islands.
+   *
+   * Used by non-SSR build output and dev replacement paths where we can import
+   * directly from discovered component paths.
+   */
+  createImportMapSourceFromDiscovered(toImportPath) {
+    const entries = Array.from(
+      this.islandsByResolvedPath,
+      ([resolvedPath, island]) => [island.islandName, resolvedPath]
+    );
+    return this.createImportMapSource(entries, toImportPath);
+  }
+  /**
+   * Build import-map source from Rollup reference ids.
+   *
+   * Used by SSR build output: reference ids are resolved to final emitted chunk
+   * file names before generating import() mappings.
+   */
+  createImportMapSourceFromReferences(resolveFileName, toImportPath) {
+    const entries = [];
+    for (const [resolvedPath, referenceId] of this.referenceIdByResolvedPath) {
+      const island = this.islandsByResolvedPath.get(resolvedPath);
+      if (!island) continue;
+      entries.push([island.islandName, resolveFileName(referenceId)]);
+    }
+    return this.createImportMapSource(entries, toImportPath);
+  }
+  createNameMapSource() {
+    const entries = Array.from(
+      this.islandsByResolvedPath,
+      ([resolvedPath, island]) => [resolvedPath, island.islandName]
+    );
+    return `new Map(${JSON.stringify(entries, null, 2)})`;
+  }
+  createImportMapSource(entries, toImportPath) {
+    const mappings = Array.from(entries, ([islandName, fileName]) => {
+      const importPath = toImportPath(fileName);
+      return `	[${JSON.stringify(islandName)}, () => import(${JSON.stringify(importPath)})],`;
+    });
+    return `new Map([
+${mappings.join("\n")}
+])`;
+  }
+}
+export {
+  ServerIslandsState
+};

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

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

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

@@ -7,36 +7,22 @@ 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);
-    return `	[${JSON.stringify(islandName)}, () => import(${JSON.stringify(importPath)})],`;
-  });
-  return `new Map([
-${mappings.join("\n")}
-])`;
-}
-function createNameMapSource(entries) {
-  return `new Map(${JSON.stringify(Array.from(entries), null, 2)})`;
-}
-function vitePluginServerIslands({ settings }) {
+function vitePluginServerIslands({
+  settings,
+  serverIslandsState
+}) {
   let command = "serve";
   let ssrEnvironment = null;
-  const serverIslandMap = /* @__PURE__ */ new Map();
-  const serverIslandNameMap = /* @__PURE__ */ new Map();
-  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);
+    for (const [resolvedPath, island] of serverIslandsState.getDiscoveredIslandEntries()) {
+      if (serverIslandsState.hasReferenceId(resolvedPath)) continue;
       const referenceId = ctx.emitFile({
         type: "chunk",
-        id: source?.id ?? resolvedPath,
-        importer: source?.importer,
-        name: islandName
+        id: island.specifier,
+        importer: island.importer,
+        name: island.islandName
       });
-      referenceIdMap.set(resolvedPath, referenceId);
+      serverIslandsState.setReferenceId(resolvedPath, referenceId);
     }
   }
   return {
@@ -86,33 +72,27 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
         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)) {
-              if (!settings.adapter) {
-                throw new AstroError(AstroErrorData.NoAdapterInstalledServerIslands);
-              }
-              let name = comp.localName;
-              let idx = 1;
-              while (serverIslandMap.has(name)) {
-                name += idx++;
-              }
-              serverIslandNameMap.set(comp.resolvedPath, name);
-              serverIslandMap.set(name, comp.resolvedPath);
-              serverIslandSourceMap.set(comp.resolvedPath, { id: comp.specifier, importer: id });
+            if (!settings.adapter) {
+              throw new AstroError(AstroErrorData.NoAdapterInstalledServerIslands);
             }
-            if (isBuildSsr && !referenceIdMap.has(comp.resolvedPath)) {
-              const islandName = serverIslandNameMap.get(comp.resolvedPath);
-              const source = serverIslandSourceMap.get(comp.resolvedPath);
+            const island = serverIslandsState.discover({
+              resolvedPath: comp.resolvedPath,
+              localName: comp.localName,
+              specifier: comp.specifier ?? comp.resolvedPath,
+              importer: id
+            });
+            if (isBuildSsr && !serverIslandsState.hasReferenceId(comp.resolvedPath)) {
               const referenceId = this.emitFile({
                 type: "chunk",
-                id: source?.id ?? comp.resolvedPath,
-                importer: source?.importer,
-                name: islandName
+                id: island.specifier,
+                importer: island.importer,
+                name: island.islandName
               });
-              referenceIdMap.set(comp.resolvedPath, referenceId);
+              serverIslandsState.setReferenceId(comp.resolvedPath, referenceId);
             }
           }
         }
-        if (serverIslandNameMap.size > 0 && serverIslandMap.size > 0 && ssrEnvironment) {
+        if (serverIslandsState.hasIslands() && ssrEnvironment) {
           const mod = ssrEnvironment.moduleGraph.getModuleById(RESOLVED_SERVER_ISLAND_MANIFEST);
           if (mod) {
             ssrEnvironment.moduleGraph.invalidateModule(mod);
@@ -120,17 +100,16 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
         }
         if (id === RESOLVED_SERVER_ISLAND_MANIFEST) {
           if (command === "build" && settings.buildOutput) {
-            const hasServerIslands = serverIslandNameMap.size > 0;
+            const hasServerIslands = serverIslandsState.hasIslands();
             if (hasServerIslands && settings.buildOutput !== "server") {
               throw new AstroError(AstroErrorData.NoAdapterInstalledServerIslands);
             }
           }
-          if (command !== "build" && serverIslandNameMap.size > 0 && serverIslandMap.size > 0) {
-            const mapSource = createServerIslandImportMapSource(
-              serverIslandMap,
+          if (command !== "build" && serverIslandsState.hasIslands()) {
+            const mapSource = serverIslandsState.createImportMapSourceFromDiscovered(
               (fileName) => fileName
             );
-            const nameMapSource = createNameMapSource(serverIslandNameMap);
+            const nameMapSource = serverIslandsState.createNameMapSource();
             return {
               code: `
 						export const serverIslandMap = ${mapSource};
@@ -150,21 +129,16 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
         if (envName === ASTRO_VITE_ENVIRONMENT_NAMES.ssr) {
           const isRelativeChunk = !chunk.isEntry;
           const dots = isRelativeChunk ? ".." : ".";
-          const mapEntries = [];
-          for (const [resolvedPath, referenceId] of referenceIdMap) {
-            const fileName = this.getFileName(referenceId);
-            const islandName = serverIslandNameMap.get(resolvedPath);
-            if (!islandName) continue;
-            mapEntries.push([islandName, fileName]);
-          }
-          mapSource = createServerIslandImportMapSource(
-            mapEntries,
+          mapSource = serverIslandsState.createImportMapSourceFromReferences(
+            (referenceId) => this.getFileName(referenceId),
             (fileName) => `${dots}/${fileName}`
           );
         } else {
-          mapSource = createServerIslandImportMapSource(serverIslandMap, (fileName) => fileName);
+          mapSource = serverIslandsState.createImportMapSourceFromDiscovered(
+            (fileName) => fileName
+          );
         }
-        const nameMapSource = createNameMapSource(serverIslandNameMap);
+        const nameMapSource = serverIslandsState.createNameMapSource();
         return {
           code: code.replace(serverIslandMapReplaceExp, mapSource).replace(serverIslandNameMapReplaceExp, nameMapSource),
           map: null

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/i18n/middleware.js

@@ -48,15 +48,22 @@ function createI18nMiddleware(i18n, base, trailingSlash, format) {
         return context.redirect(location, routeDecision.status);
       }
       case "notFound": {
-        const notFoundRes = new Response(response.body, {
-          status: 404,
-          headers: response.headers
-        });
-        notFoundRes.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
+        if (context.isPrerendered) {
+          const prerenderedRes = new Response(response.body, {
+            status: 404,
+            headers: response.headers
+          });
+          prerenderedRes.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
+          if (routeDecision.location) {
+            prerenderedRes.headers.set("Location", routeDecision.location);
+          }
+          return prerenderedRes;
+        }
+        const headers = new Headers();
         if (routeDecision.location) {
-          notFoundRes.headers.set("Location", routeDecision.location);
+          headers.set("Location", routeDecision.location);
         }
-        return notFoundRes;
+        return new Response(null, { status: 404, headers });
       }
       case "continue":
         break;

package/dist/i18n/utils.d.ts

@@ -21,4 +21,10 @@ export declare function parseLocale(header: string): BrowserLocale[];
 export declare function computePreferredLocale(request: Request, locales: Locales): string | undefined;
 export declare function computePreferredLocaleList(request: Request, locales: Locales): string[];
 export declare function computeCurrentLocale(pathname: string, locales: Locales, defaultLocale: string): string | undefined;
+/**
+ * Check if any of the route's resolved param values match a configured locale.
+ * This handles dynamic routes like `[locale]` or `[...path]` where the locale
+ * isn't in a static segment of the route pathname.
+ */
+export declare function computeCurrentLocaleFromParams(params: Record<string, string | undefined>, locales: Locales): string | undefined;
 export {};

package/dist/i18n/utils.js

@@ -134,8 +134,30 @@ function computeCurrentLocale(pathname, locales, defaultLocale) {
     }
   }
 }
+function computeCurrentLocaleFromParams(params, locales) {
+  const byNormalizedCode = /* @__PURE__ */ new Map();
+  const byPath = /* @__PURE__ */ new Map();
+  for (const locale of locales) {
+    if (typeof locale === "string") {
+      byNormalizedCode.set(normalizeTheLocale(locale), locale);
+    } else {
+      byPath.set(locale.path, locale.codes[0]);
+      for (const code of locale.codes) {
+        byNormalizedCode.set(normalizeTheLocale(code), code);
+      }
+    }
+  }
+  for (const value of Object.values(params)) {
+    if (!value) continue;
+    const pathMatch = byPath.get(value);
+    if (pathMatch) return pathMatch;
+    const codeMatch = byNormalizedCode.get(normalizeTheLocale(value));
+    if (codeMatch) return codeMatch;
+  }
+}
 export {
   computeCurrentLocale,
+  computeCurrentLocaleFromParams,
   computePreferredLocale,
   computePreferredLocaleList,
   parseLocale

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,17 @@ function serializedManifestPlugin({
   command,
   sync
 }) {
+  const normalizedSrcDir = normalizePath(fileURLToPath(settings.config.srcDir));
+  let encodedKeyPromise;
+  function getEncodedKey() {
+    encodedKeyPromise ??= (async () => {
+      const key = hasEnvironmentKey() ? await getEnvironmentKey() : await createKey();
+      return encodeKey(key);
+    })();
+    return encodedKeyPromise;
+  }
   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;
@@ -64,7 +75,7 @@ function serializedManifestPlugin({
         if (command === "build" && !sync) {
           manifestData = `'${MANIFEST_REPLACE}'`;
         } else {
-          const serialized = await createSerializedManifest(settings);
+          const serialized = await createSerializedManifest(settings, await getEncodedKey());
           manifestData = JSON.stringify(serialized);
         }
         const hasCacheConfig = !!settings.config.experimental?.cache?.provider;
@@ -100,7 +111,7 @@ function serializedManifestPlugin({
     }
   };
 }
-async function createSerializedManifest(settings) {
+async function createSerializedManifest(settings, encodedKey) {
   let i18nManifest;
   let csp;
   if (settings.config.i18n) {
@@ -158,7 +169,7 @@ async function createSerializedManifest(settings) {
     // 1mb default
     serverIslandBodySizeLimit: settings.config.security?.serverIslandBodySizeLimit ? settings.config.security.serverIslandBodySizeLimit : 1024 * 1024,
     // 1mb default
-    key: await encodeKey(hasEnvironmentKey() ? await getEnvironmentKey() : await createKey()),
+    key: encodedKey ?? await encodeKey(hasEnvironmentKey() ? await getEnvironmentKey() : await createKey()),
     sessionConfig: sessionConfigToManifest(settings.config.session),
     cacheConfig: cacheConfigToManifest(
       settings.config.experimental?.cache,

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 { isRouteServerIsland, matchAllRoutes } from "../core/routing/match.js";
+import { 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 || isRouteServerIsland(route))) {
+                if (!matches.some((route) => route.prerender)) {
                   return next();
                 }
                 localStorage.run(request, () => {

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

@@ -18,6 +18,23 @@ import {
 function getComponentFromVirtualModuleCssName(virtualModulePrefix, id) {
   return id.slice(virtualModulePrefix.length).replace(new RegExp(ASTRO_CSS_EXTENSION_POST_PATTERN, "g"), ".");
 }
+async function ensureModulesLoaded(env, mod, seen = /* @__PURE__ */ new Set()) {
+  const id = mod.id ?? mod.url;
+  if (seen.has(id)) return;
+  seen.add(id);
+  for (const imp of mod.importedModules) {
+    if (!imp.id) continue;
+    if (seen.has(imp.id)) continue;
+    if (imp.id.includes(PROPAGATED_ASSET_QUERY_PARAM)) continue;
+    if (!imp.transformResult) {
+      try {
+        await env.fetchModule(imp.id);
+      } catch {
+      }
+    }
+    await ensureModulesLoaded(env, imp, seen);
+  }
+}
 function* collectCSSWithOrder(id, mod, seen = /* @__PURE__ */ new Set()) {
   seen.add(id);
   if (id.includes(PROPAGATED_ASSET_QUERY_PARAM)) {
@@ -98,6 +115,9 @@ function astroDevCssPlugin({ routesList, command }) {
                 code: "export const css = new Set()"
               };
             }
+            if (env) {
+              await ensureModulesLoaded(env, mod);
+            }
             for (const collected of collectCSSWithOrder(componentPageId, mod)) {
               if (!cssWithOrder.has(collected.idKey)) {
                 const content = cssContentCache.get(collected.id) || collected.content;

package/dist/vite-plugin-renderers/index.d.ts

@@ -1,9 +1,11 @@
 import type { ConfigEnv, Plugin as VitePlugin } from 'vite';
+import type { ServerIslandsState } from '../core/server-islands/shared-state.js';
 import type { AstroSettings, RoutesList } from '../types/astro.js';
 export declare const ASTRO_RENDERERS_MODULE_ID = "virtual:astro:renderers";
 interface PluginOptions {
     settings: AstroSettings;
     routesList: RoutesList;
+    serverIslandsState: ServerIslandsState;
     command: ConfigEnv['command'];
 }
 export default function vitePluginRenderers(options: PluginOptions): VitePlugin;

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

@@ -20,7 +20,7 @@ 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 && !hasNonPrerenderedProjectRoute(options.routesList.routes, {
+        if (options.command === "build" && this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr && renderers.length > 0 && !options.serverIslandsState.hasIslands() && !hasNonPrerenderedProjectRoute(options.routesList.routes, {
           includeEndpoints: false
         })) {
           return { code: `export const renderers = [];` };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.0.5",
+  "version": "6.0.7",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -153,8 +153,8 @@
     "xxhash-wasm": "^1.1.0",
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6",
-    "@astrojs/markdown-remark": "7.0.0",
     "@astrojs/internal-helpers": "0.8.0",
+    "@astrojs/markdown-remark": "7.0.1",
     "@astrojs/telemetry": "3.3.0"
   },
   "optionalDependencies": {
@@ -194,7 +194,7 @@
     "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 = {