astro 6.0.4 → 6.0.6

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/actions/integration.js

@@ -1,5 +1,6 @@
 import { AstroError } from "../core/errors/errors.js";
 import { ActionsWithoutServerOutputError } from "../core/errors/errors-data.js";
+import { hasNonPrerenderedProjectRoute } from "../core/routing/helpers.js";
 import { viteID } from "../core/util.js";
 import { ACTION_RPC_ROUTE_PATTERN, ACTIONS_TYPES_FILE, VIRTUAL_MODULE_ID } from "./consts.js";
 function astroIntegrationActionsRouteHandler({
@@ -18,20 +19,22 @@ function astroIntegrationActionsRouteHandler({
         });
       },
       "astro:config:done": async (params) => {
-        if (params.buildOutput === "static") {
-          const error = new AstroError(ActionsWithoutServerOutputError);
-          error.stack = void 0;
-          throw error;
-        }
         const stringifiedActionsImport = JSON.stringify(
           viteID(new URL(`./${filename}`, params.config.srcDir))
         );
         settings.injectedTypes.push({
           filename: ACTIONS_TYPES_FILE,
           content: `declare module "astro:actions" {
-	export const actions: typeof import(${stringifiedActionsImport})["server"];
+		export const actions: typeof import(${stringifiedActionsImport})["server"];
 }`
         });
+      },
+      "astro:routes:resolved": ({ routes }) => {
+        if (!hasNonPrerenderedProjectRoute(routes)) {
+          const error = new AstroError(ActionsWithoutServerOutputError);
+          error.stack = void 0;
+          throw error;
+        }
       }
     }
   };

package/dist/assets/runtime.d.ts

@@ -3,8 +3,9 @@ export interface SvgComponentProps {
     meta: ImageMetadata;
     attributes: Record<string, string>;
     children: string;
+    styles: string[];
 }
-export declare function createSvgComponent({ meta, attributes, children }: SvgComponentProps): import("../runtime/server/index.js").AstroComponentFactory & ImageMetadata;
+export declare function createSvgComponent({ meta, attributes, children, styles }: SvgComponentProps): import("../runtime/server/index.js").AstroComponentFactory & ImageMetadata;
 type SvgAttributes = Record<string, any>;
 export declare function dropAttributes(attributes: SvgAttributes): SvgAttributes;
 export {};

package/dist/assets/runtime.js

@@ -1,13 +1,24 @@
+import { generateCspDigest } from "../core/encryption.js";
 import {
   createComponent,
   render,
   spreadAttributes,
   unescapeHTML
 } from "../runtime/server/index.js";
-function createSvgComponent({ meta, attributes, children }) {
-  const Component = createComponent((_, props) => {
-    const normalizedProps = normalizeProps(attributes, props);
-    return render`<svg${spreadAttributes(normalizedProps)}>${unescapeHTML(children)}</svg>`;
+function createSvgComponent({ meta, attributes, children, styles }) {
+  const hasStyles = styles.length > 0;
+  const Component = createComponent({
+    async factory(result, props) {
+      const normalizedProps = normalizeProps(attributes, props);
+      if (hasStyles && result.cspDestination) {
+        for (const style of styles) {
+          const hash = await generateCspDigest(style, result.cspAlgorithm);
+          result._metadata.extraStyleHashes.push(hash);
+        }
+      }
+      return render`<svg${spreadAttributes(normalizedProps)}>${unescapeHTML(children)}</svg>`;
+    },
+    propagation: hasStyles ? "self" : "none"
   });
   if (import.meta.env.DEV) {
     makeNonEnumerable(Component);

package/dist/assets/utils/svg.js

@@ -1,5 +1,5 @@
 import { optimize } from "svgo";
-import { parse, renderSync } from "ultrahtml";
+import { ELEMENT_NODE, TEXT_NODE, parse, renderSync } from "ultrahtml";
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 import { dropAttributes } from "../runtime.js";
 function parseSvg({
@@ -25,18 +25,31 @@ function parseSvg({
   }
   const root = parse(processedContents);
   const svgNode = root.children.find(
-    ({ name, type }) => type === 1 && name === "svg"
+    ({ name, type }) => type === ELEMENT_NODE && name === "svg"
   );
   if (!svgNode) {
     throw new Error("SVG file does not contain an <svg> element");
   }
   const { attributes, children } = svgNode;
   const body = renderSync({ ...root, children });
-  return { attributes, body };
+  const styles = [];
+  for (const child of children) {
+    if (child.type === ELEMENT_NODE && child.name === "style") {
+      const textContent = child.children?.filter((c) => c.type === TEXT_NODE).map((c) => c.value).join("");
+      if (textContent) {
+        styles.push(textContent);
+      }
+    }
+  }
+  return { attributes, body, styles };
 }
 function makeSvgComponent(meta, contents, svgoConfig) {
   const file = typeof contents === "string" ? contents : contents.toString("utf-8");
-  const { attributes, body: children } = parseSvg({
+  const {
+    attributes,
+    body: children,
+    styles
+  } = parseSvg({
     path: meta.fsPath,
     contents: file,
     svgoConfig
@@ -44,19 +57,24 @@ function makeSvgComponent(meta, contents, svgoConfig) {
   const props = {
     meta,
     attributes: dropAttributes(attributes),
-    children
+    children,
+    styles
   };
   return `import { createSvgComponent } from 'astro/assets/runtime';
 export default createSvgComponent(${JSON.stringify(props)})`;
 }
 function parseSvgComponentData(meta, contents, svgoConfig) {
   const file = typeof contents === "string" ? contents : contents.toString("utf-8");
-  const { attributes, body: children } = parseSvg({
+  const {
+    attributes,
+    body: children,
+    styles
+  } = parseSvg({
     path: meta.fsPath,
     contents: file,
     svgoConfig
   });
-  return { attributes: dropAttributes(attributes), children };
+  return { attributes: dropAttributes(attributes), children, styles };
 }
 export {
   makeSvgComponent,

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.4";
+  version = "6.0.6";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

@@ -189,7 +189,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.0.4") {
+    if (previousAstroVersion && previousAstroVersion !== "6.0.6") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -197,8 +197,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.0.4") {
-      this.#store.metaStore().set("astro-version", "6.0.4");
+    if ("6.0.6") {
+      this.#store.metaStore().set("astro-version", "6.0.6");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/server-listeners.js

@@ -6,6 +6,10 @@ async function attachContentServerListeners({
   logger,
   settings
 }) {
+  const maxListeners = viteServer.watcher.getMaxListeners();
+  if (maxListeners !== 0 && maxListeners < 50) {
+    viteServer.watcher.setMaxListeners(50);
+  }
   const contentGenerator = await createContentTypesGenerator({
     fs,
     settings,

package/dist/content/types-generator.js

@@ -463,7 +463,10 @@ async function generateJSONSchema(fsMod, collectionConfig, collectionKey, collec
           ctx.jsonSchema.type = "string";
           ctx.jsonSchema.format = "date-time";
         }
-      }
+      },
+      // Collection schemas are used for parsing collection input, so we need to tell Zod to use the
+      // input shape when generating a JSON schema.
+      io: "input"
     });
     const schemaStr = JSON.stringify(schema, null, 2);
     const schemaJsonPath = new URL(

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/build/generate.js

@@ -61,102 +61,106 @@ async function generatePages(options, internals, prerenderOutputDir) {
   const verb = ssr ? "prerendering" : "generating";
   logger.info("SKIP_FORMAT", `
 ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
-  const pathsWithRoutes = await prerenderer.getStaticPaths();
   const routeToHeaders = /* @__PURE__ */ new Map();
-  const hasI18nDomains = ssr && options.settings.config.i18n?.domains && Object.keys(options.settings.config.i18n.domains).length > 0;
-  const { config } = options.settings;
-  const builtPaths = /* @__PURE__ */ new Set();
-  const filteredPaths = pathsWithRoutes.filter(({ pathname, route }) => {
-    if (hasI18nDomains && route.prerender) {
-      throw new AstroError({
-        ...AstroErrorData.NoPrerenderedRoutesWithDomains,
-        message: AstroErrorData.NoPrerenderedRoutesWithDomains.message(route.component)
-      });
-    }
-    const normalized = removeTrailingForwardSlash(pathname);
-    if (!builtPaths.has(normalized)) {
-      builtPaths.add(normalized);
-      return true;
-    }
-    const matchedRoute = matchRoute(decodeURI(pathname), options.routesList);
-    if (!matchedRoute) {
-      return false;
-    }
-    if (matchedRoute === route) {
-      return true;
-    }
-    if (config.prerenderConflictBehavior === "error") {
-      throw new AstroError({
-        ...AstroErrorData.PrerenderRouteConflict,
-        message: AstroErrorData.PrerenderRouteConflict.message(
+  let staticImageList = getStaticImageList();
+  try {
+    const pathsWithRoutes = await prerenderer.getStaticPaths();
+    const hasI18nDomains = ssr && options.settings.config.i18n?.domains && Object.keys(options.settings.config.i18n.domains).length > 0;
+    const { config } = options.settings;
+    const builtPaths = /* @__PURE__ */ new Set();
+    const filteredPaths = pathsWithRoutes.filter(({ pathname, route }) => {
+      if (hasI18nDomains && route.prerender) {
+        throw new AstroError({
+          ...AstroErrorData.NoPrerenderedRoutesWithDomains,
+          message: AstroErrorData.NoPrerenderedRoutesWithDomains.message(route.component)
+        });
+      }
+      const normalized = removeTrailingForwardSlash(pathname);
+      if (!builtPaths.has(normalized)) {
+        builtPaths.add(normalized);
+        return true;
+      }
+      const matchedRoute = matchRoute(decodeURI(pathname), options.routesList);
+      if (!matchedRoute) {
+        return false;
+      }
+      if (matchedRoute === route) {
+        return true;
+      }
+      if (config.prerenderConflictBehavior === "error") {
+        throw new AstroError({
+          ...AstroErrorData.PrerenderRouteConflict,
+          message: AstroErrorData.PrerenderRouteConflict.message(
+            matchedRoute.route,
+            route.route,
+            normalized
+          ),
+          hint: AstroErrorData.PrerenderRouteConflict.hint(matchedRoute.route, route.route)
+        });
+      } else if (config.prerenderConflictBehavior === "warn") {
+        const msg = AstroErrorData.PrerenderRouteConflict.message(
           matchedRoute.route,
           route.route,
           normalized
-        ),
-        hint: AstroErrorData.PrerenderRouteConflict.hint(matchedRoute.route, route.route)
-      });
-    } else if (config.prerenderConflictBehavior === "warn") {
-      const msg = AstroErrorData.PrerenderRouteConflict.message(
-        matchedRoute.route,
-        route.route,
-        normalized
-      );
-      logger.warn("build", msg);
-    }
-    return false;
-  });
-  if (config.build.concurrency > 1) {
-    const limit = PLimit(config.build.concurrency);
-    const BATCH_SIZE = 1e5;
-    for (let i = 0; i < filteredPaths.length; i += BATCH_SIZE) {
-      const batch = filteredPaths.slice(i, i + BATCH_SIZE);
-      const promises = [];
-      for (const { pathname, route } of batch) {
-        promises.push(
-          limit(
-            () => generatePathWithPrerenderer(
-              prerenderer,
-              pathname,
-              route,
-              options,
-              routeToHeaders,
-              logger
+        );
+        logger.warn("build", msg);
+      }
+      return false;
+    });
+    if (config.build.concurrency > 1) {
+      const limit = PLimit(config.build.concurrency);
+      const BATCH_SIZE = 1e5;
+      for (let i = 0; i < filteredPaths.length; i += BATCH_SIZE) {
+        const batch = filteredPaths.slice(i, i + BATCH_SIZE);
+        const promises = [];
+        for (const { pathname, route } of batch) {
+          promises.push(
+            limit(
+              () => generatePathWithPrerenderer(
+                prerenderer,
+                pathname,
+                route,
+                options,
+                routeToHeaders,
+                logger
+              )
             )
-          )
+          );
+        }
+        await Promise.all(promises);
+      }
+    } else {
+      for (const { pathname, route } of filteredPaths) {
+        await generatePathWithPrerenderer(
+          prerenderer,
+          pathname,
+          route,
+          options,
+          routeToHeaders,
+          logger
         );
       }
-      await Promise.all(promises);
-    }
-  } else {
-    for (const { pathname, route } of filteredPaths) {
-      await generatePathWithPrerenderer(
-        prerenderer,
-        pathname,
-        route,
-        options,
-        routeToHeaders,
-        logger
-      );
     }
-  }
-  for (const { route: generatedRoute } of filteredPaths) {
-    if (generatedRoute.distURL && generatedRoute.distURL.length > 0) {
-      for (const pageData of Object.values(options.allPages)) {
-        if (pageData.route.route === generatedRoute.route && pageData.route.component === generatedRoute.component) {
-          pageData.route.distURL = generatedRoute.distURL;
-          break;
+    for (const { route: generatedRoute } of filteredPaths) {
+      if (generatedRoute.distURL && generatedRoute.distURL.length > 0) {
+        for (const pageData of Object.values(options.allPages)) {
+          if (pageData.route.route === generatedRoute.route && pageData.route.component === generatedRoute.component) {
+            pageData.route.distURL = generatedRoute.distURL;
+            break;
+          }
         }
       }
     }
-  }
-  const staticImageList = getStaticImageList();
-  if (prerenderer.collectStaticImages) {
-    const adapterImages = await prerenderer.collectStaticImages();
-    for (const [path, entry] of adapterImages) {
-      staticImageList.set(path, entry);
+    staticImageList = getStaticImageList();
+    if (prerenderer.collectStaticImages) {
+      const adapterImages = await prerenderer.collectStaticImages();
+      for (const [path, entry] of adapterImages) {
+        staticImageList.set(path, entry);
+      }
     }
+  } finally {
+    await prerenderer.teardown?.();
   }
-  await prerenderer.teardown?.();
   logger.info(
     null,
     colors.green(`\u2713 Completed in ${getTimeStat(generatePagesTimer, performance.now())}.
@@ -328,7 +332,11 @@ function getUrlForPath(pathname, base, origin, format, trailingSlash, routeType)
   }
   let buildPathname;
   if (pathname === "/" || pathname === "") {
-    buildPathname = collapseDuplicateTrailingSlashes(base + ending, trailingSlash !== "never");
+    if (format === "file") {
+      buildPathname = joinPaths(base, "index.html");
+    } else {
+      buildPathname = collapseDuplicateTrailingSlashes(base + ending, trailingSlash !== "never");
+    }
   } else if (routeType === "endpoint") {
     const buildPathRelative = removeLeadingForwardSlash(pathname);
     buildPathname = joinPaths(base, buildPathRelative);

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

@@ -1,7 +1,17 @@
 import { normalizeEntryId } from "./plugin-component-entry.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+function getRollupInputAsSet(rollupInput) {
+  if (Array.isArray(rollupInput)) {
+    return new Set(rollupInput);
+  } else if (typeof rollupInput === "string") {
+    return /* @__PURE__ */ new Set([rollupInput]);
+  } else if (rollupInput && typeof rollupInput === "object") {
+    return new Set(Object.values(rollupInput));
+  } else {
+    return /* @__PURE__ */ new Set();
+  }
+}
 function pluginInternals(options, internals) {
-  let input;
   return {
     name: "@astro/plugin-build-internals",
     applyToEnvironment(environment) {
@@ -27,19 +37,8 @@ function pluginInternals(options, internals) {
         };
       }
     },
-    configResolved(config) {
-      const rollupInput = config.build?.rollupOptions?.input;
-      if (Array.isArray(rollupInput)) {
-        input = new Set(rollupInput);
-      } else if (typeof rollupInput === "string") {
-        input = /* @__PURE__ */ new Set([rollupInput]);
-      } else if (rollupInput && typeof rollupInput === "object") {
-        input = new Set(Object.values(rollupInput));
-      } else {
-        input = /* @__PURE__ */ new Set();
-      }
-    },
     async generateBundle(_options, bundle) {
+      const input = getRollupInputAsSet(this.environment?.config.build.rollupOptions.input);
       const promises = [];
       const mapping = /* @__PURE__ */ new Map();
       const allInput = /* @__PURE__ */ new Set([...input, ...internals.clientInput]);

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/build/static-build.js

@@ -34,7 +34,7 @@ import { encodeName, getTimeStat, viteBuildReturnToRollupOutputs } from "./util.
 import { NOOP_MODULE_ID } from "./plugins/plugin-noop.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
 import { getSSRAssets } from "./internal.js";
-import { serverIslandPlaceholderMap } from "../server-islands/vite-plugin-server-islands.js";
+import { SERVER_ISLAND_MAP_MARKER } from "../server-islands/vite-plugin-server-islands.js";
 const PRERENDER_ENTRY_FILENAME_PREFIX = "prerender-entry";
 function extractRelevantChunks(outputs, prerender) {
   const extracted = [];
@@ -43,7 +43,7 @@ function extractRelevantChunks(outputs, prerender) {
       if (chunk.type === "asset") continue;
       const needsContentInjection = chunk.code.includes(LINKS_PLACEHOLDER);
       const needsManifestInjection = chunk.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID);
-      const needsServerIslandInjection = chunk.code.includes(serverIslandPlaceholderMap);
+      const needsServerIslandInjection = chunk.code.includes(SERVER_ISLAND_MAP_MARKER);
       if (needsContentInjection || needsManifestInjection || needsServerIslandInjection) {
         extracted.push({
           fileName: chunk.fileName,
@@ -218,6 +218,13 @@ async function buildEnvironments(opts, internals) {
     // This takes precedence over platform plugin fallbacks (e.g., Cloudflare)
     builder: {
       async buildApp(builder2) {
+        settings.timer.start("Prerender build");
+        let prerenderOutput = await builder2.build(builder2.environments.prerender);
+        settings.timer.end("Prerender build");
+        extractPrerenderEntryFileName(internals, prerenderOutput);
+        const prerenderOutputs = viteBuildReturnToRollupOutputs(prerenderOutput);
+        const prerenderChunks = extractRelevantChunks(prerenderOutputs, true);
+        prerenderOutput = void 0;
         let ssrChunks = [];
         if (settings.buildOutput !== "static") {
           settings.timer.start("SSR build");
@@ -229,13 +236,6 @@ async function buildEnvironments(opts, internals) {
           ssrChunks = extractRelevantChunks(ssrOutputs, false);
           ssrOutput = void 0;
         }
-        settings.timer.start("Prerender build");
-        let prerenderOutput = await builder2.build(builder2.environments.prerender);
-        settings.timer.end("Prerender build");
-        extractPrerenderEntryFileName(internals, prerenderOutput);
-        const prerenderOutputs = viteBuildReturnToRollupOutputs(prerenderOutput);
-        const prerenderChunks = extractRelevantChunks(prerenderOutputs, true);
-        prerenderOutput = void 0;
         const ssrPlugins = builder2.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]?.config.plugins ?? [];
         buildPostHooks = ssrPlugins.map(
           (plugin) => typeof plugin.api?.buildPostHook === "function" ? plugin.api.buildPostHook : void 0

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.0.4";
+const ASTRO_VERSION = "6.0.6";
 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/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.4";
+  const currentVersion = "6.0.6";
   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.4"}`
+        `v${"6.0.6"}`
       )} ${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;
 }