astro 6.4.3 → 6.4.5

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

package/dist/content/content-layer.js

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

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

@@ -131,6 +131,15 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
     abstract createPipeline(streaming: boolean, manifest: SSRManifest, ...args: any[]): P;
     set setManifestData(newManifestData: RoutesList);
     removeBase(pathname: string): string;
+    /**
+     * Decodes a pathname with `decodeURI`, falling back to the raw pathname when it
+     * contains an invalid percent-sequence (e.g. `%C0%AF`, an overlong-UTF-8 encoding of
+     * `/` commonly sent by path-traversal scanners). A raw `decodeURI()` would throw
+     * `URIError: URI malformed`, and because `match()` runs before `render()` that error
+     * escapes the adapter's request handler as an uncaught exception (HTTP 500) that user
+     * middleware can't catch.
+     */
+    private safeDecodeURI;
     /**
      * Extracts the base-stripped, decoded pathname from a request.
      * Used by adapters to compute the pathname for dev-mode route matching.

package/dist/core/app/base.js

@@ -1,12 +1,10 @@
 import {
-  appendForwardSlash,
   collapseDuplicateLeadingSlashes,
-  joinPaths,
   prependForwardSlash,
   removeTrailingForwardSlash
 } from "@astrojs/internal-helpers/path";
 import { matchPattern } from "@astrojs/internal-helpers/remote";
-import { normalizeTheLocale } from "../../i18n/index.js";
+import { computePathnameFromDomain } from "../i18n/domain.js";
 import { PipelineFeatures } from "../base-pipeline.js";
 import { ASTRO_ERROR_HEADER, clientAddressSymbol } from "../constants.js";
 import { getSetCookiesFromResponse } from "../cookies/index.js";
@@ -46,11 +44,9 @@ class BaseApp {
     return this.pipeline.logger;
   }
   get adapterLogger() {
-    if (!this.#adapterLogger) {
-      this.#adapterLogger = new AstroIntegrationLogger(
-        this.logger.options,
-        this.manifest.adapterName
-      );
+    const currentOptions = this.logger.options;
+    if (!this.#adapterLogger || this.#adapterLogger.options !== currentOptions) {
+      this.#adapterLogger = new AstroIntegrationLogger(currentOptions, this.manifest.adapterName);
     }
     return this.#adapterLogger;
   }
@@ -117,19 +113,30 @@ class BaseApp {
     return pathname;
   }
   /**
-   * Extracts the base-stripped, decoded pathname from a request.
-   * Used by adapters to compute the pathname for dev-mode route matching.
+   * Decodes a pathname with `decodeURI`, falling back to the raw pathname when it
+   * contains an invalid percent-sequence (e.g. `%C0%AF`, an overlong-UTF-8 encoding of
+   * `/` commonly sent by path-traversal scanners). A raw `decodeURI()` would throw
+   * `URIError: URI malformed`, and because `match()` runs before `render()` that error
+   * escapes the adapter's request handler as an uncaught exception (HTTP 500) that user
+   * middleware can't catch.
    */
-  getPathnameFromRequest(request) {
-    const url = new URL(request.url);
-    const pathname = prependForwardSlash(this.removeBase(url.pathname));
+  safeDecodeURI(pathname) {
     try {
       return decodeURI(pathname);
     } catch (e) {
-      this.adapterLogger.error(e.toString());
+      this.adapterLogger.debug(e.toString());
       return pathname;
     }
   }
+  /**
+   * Extracts the base-stripped, decoded pathname from a request.
+   * Used by adapters to compute the pathname for dev-mode route matching.
+   */
+  getPathnameFromRequest(request) {
+    const url = new URL(request.url);
+    const pathname = prependForwardSlash(this.removeBase(url.pathname));
+    return this.safeDecodeURI(pathname);
+  }
   /**
    * Given a `Request`, it returns the `RouteData` that matches its `pathname`. By default, prerendered
    * routes aren't returned, even if they are matched.
@@ -145,14 +152,14 @@ class BaseApp {
     if (!pathname) {
       pathname = prependForwardSlash(this.removeBase(url.pathname));
     }
-    const routeData = this.pipeline.matchRoute(decodeURI(pathname));
+    const routeData = this.pipeline.matchRoute(this.safeDecodeURI(pathname));
     if (!routeData) return void 0;
     if (allowPrerenderedRoutes) {
       return routeData;
     }
     if (routeData.prerender) {
       if (routeData.params.length > 0) {
-        const allMatches = this.pipeline.matchAllRoutes(decodeURI(pathname));
+        const allMatches = this.pipeline.matchAllRoutes(this.safeDecodeURI(pathname));
         return allMatches.find((r) => !r.prerender);
       }
       return void 0;
@@ -170,55 +177,14 @@ class BaseApp {
     return void 0;
   }
   computePathnameFromDomain(request) {
-    let pathname = void 0;
-    const url = new URL(request.url);
-    if (this.manifest.i18n && (this.manifest.i18n.strategy === "domains-prefix-always" || this.manifest.i18n.strategy === "domains-prefix-other-locales" || this.manifest.i18n.strategy === "domains-prefix-always-no-redirect")) {
-      let host = request.headers.get("X-Forwarded-Host");
-      let protocol = request.headers.get("X-Forwarded-Proto");
-      if (protocol) {
-        protocol = protocol + ":";
-      } else {
-        protocol = url.protocol;
-      }
-      if (!host) {
-        host = request.headers.get("Host");
-      }
-      if (host && protocol) {
-        host = host.split(":")[0];
-        try {
-          let locale;
-          const hostAsUrl = new URL(`${protocol}//${host}`);
-          for (const [domainKey, localeValue] of Object.entries(
-            this.manifest.i18n.domainLookupTable
-          )) {
-            const domainKeyAsUrl = new URL(domainKey);
-            if (hostAsUrl.host === domainKeyAsUrl.host && hostAsUrl.protocol === domainKeyAsUrl.protocol) {
-              locale = localeValue;
-              break;
-            }
-          }
-          if (locale) {
-            pathname = prependForwardSlash(
-              joinPaths(normalizeTheLocale(locale), this.removeBase(url.pathname))
-            );
-            if (this.manifest.trailingSlash === "always") {
-              pathname = appendForwardSlash(pathname);
-            } else if (this.manifest.trailingSlash === "never") {
-              pathname = removeTrailingForwardSlash(pathname);
-            } else if (url.pathname.endsWith("/")) {
-              pathname = appendForwardSlash(pathname);
-            }
-          }
-        } catch (e) {
-          this.logger.error(
-            "router",
-            `Astro tried to parse ${protocol}//${host} as an URL, but it threw a parsing error. Check the X-Forwarded-Host and X-Forwarded-Proto headers.`
-          );
-          this.logger.error("router", `Error: ${e}`);
-        }
-      }
-    }
-    return pathname;
+    return computePathnameFromDomain(
+      request,
+      new URL(request.url),
+      this.manifest.i18n,
+      this.manifest.base,
+      this.manifest.trailingSlash,
+      this.logger
+    );
   }
   async render(request, {
     addCookieHeader = false,
@@ -259,7 +225,7 @@ class BaseApp {
     if (!routeData) {
       const domainPathname = this.computePathnameFromDomain(request);
       if (domainPathname) {
-        routeData = this.pipeline.matchRoute(decodeURI(domainPathname));
+        routeData = this.pipeline.matchRoute(this.safeDecodeURI(domainPathname));
       }
     }
     const resolvedOptions = {

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.4.3";
+const ASTRO_VERSION = "6.4.5";
 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

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

package/dist/core/errors/errors-data.d.ts

@@ -185,8 +185,8 @@ export declare const NoClientOnlyHint: {
  * ---
  * export async function getStaticPaths() {
  *	return [
- *		{ params: { slug: "blog" } },
- * 		{ params: { slug: "about" } }
+ *		{ params: { id: "blog" } },
+ * 		{ params: { id: "about" } }
  * 	];
  *}
  *---
@@ -208,8 +208,8 @@ export declare const InvalidGetStaticPathParam: {
  * ```ts title="pages/blog/[id].astro"
  * export async function getStaticPaths() {
  *	return [ // <-- Array
- *		{ params: { slug: "blog" } }, // <-- Object
- * 		{ params: { slug: "about" } }
+ *		{ params: { id: "blog" } }, // <-- Object
+ * 		{ params: { id: "about" } }
  * 	];
  *}
  * ```
@@ -231,8 +231,8 @@ export declare const InvalidGetStaticPathsEntry: {
  * ```ts title="pages/blog/[id].astro"
  * export async function getStaticPaths() {
  *	return [ // <-- Array
- *		{ params: { slug: "blog" } },
- * 		{ params: { slug: "about" } }
+ *		{ params: { id: "blog" } },
+ * 		{ params: { id: "about" } }
  * 	];
  *}
  * ```

package/dist/core/fetch/fetch-state.js

@@ -9,6 +9,7 @@ import { createCallAction, createGetActionResult, hasActionPayload } from "../..
 import { AstroCookies } from "../cookies/index.js";
 import { Slots } from "../render/index.js";
 import {
+  appSymbol,
   ASTRO_GENERATOR,
   fetchStateSymbol,
   originPathnameSymbol,
@@ -29,6 +30,7 @@ import { Rewrites } from "../rewrites/handler.js";
 import { isRoute404or500, isRouteServerIsland } from "../routing/match.js";
 import { normalizeUrl } from "../util/normalized-url.js";
 import { getOriginPathname, setOriginPathname } from "../routing/rewrite.js";
+import { computePathnameFromDomain } from "../i18n/domain.js";
 import { getCustom404Route, routeHasHtmlExtension } from "../routing/helpers.js";
 import { getRenderOptions } from "../app/render-options.js";
 import { getFirstForwardedValue, validateForwardedHeaders } from "../app/validate-headers.js";
@@ -136,6 +138,13 @@ class FetchState {
   #rewrites;
   /** Memoized Astro page partial. */
   #astroPagePartial;
+  /**
+   * Locale-prefixed pathname derived from the Host header for domain-based
+   * i18n routing (e.g. `/en/boats/1/foo`), or `undefined` when the request
+   * isn't served from a locale-mapped domain. When set, `this.pathname` is
+   * derived from it so locale/param resolution match the route pattern.
+   */
+  #domainPathname;
   /** Memoized current locale. */
   #currentLocale;
   /** Memoized preferred locale. */
@@ -158,7 +167,24 @@ class FetchState {
     this.componentInstance = void 0;
     this.slots = void 0;
     const url = new URL(request.url);
-    this.pathname = this.#computePathname(url);
+    const domainPathname = computePathnameFromDomain(
+      request,
+      url,
+      pipeline.manifest.i18n,
+      pipeline.manifest.base,
+      pipeline.manifest.trailingSlash,
+      pipeline.logger
+    );
+    if (domainPathname) {
+      this.#domainPathname = domainPathname;
+      try {
+        this.pathname = decodeURI(domainPathname);
+      } catch {
+        this.pathname = domainPathname;
+      }
+    } else {
+      this.pathname = this.#computePathname(url);
+    }
     this.timeStart = performance.now();
     this.clientAddress = options?.clientAddress;
     this.locals = options?.locals ?? {};
@@ -167,9 +193,9 @@ class FetchState {
     if (pipeline.manifest.allowedDomains && pipeline.manifest.allowedDomains.length > 0) {
       this.#applyForwardedHeaders();
     }
-    if (!Reflect.get(request, originPathnameSymbol)) {
+    if (!Reflect.get(this.request, originPathnameSymbol)) {
       setOriginPathname(
-        request,
+        this.request,
         this.pathname,
         pipeline.manifest.trailingSlash,
         pipeline.manifest.buildFormat
@@ -462,7 +488,9 @@ class FetchState {
       }
     } else {
       let pathname = routeData.pathname;
-      if (url && !routeData.pattern.test(url.pathname)) {
+      if (this.#domainPathname) {
+        pathname = this.pathname;
+      } else if (url && !routeData.pattern.test(url.pathname)) {
         for (const fallbackRoute of routeData.fallbackRoutes) {
           if (fallbackRoute.pattern.test(url.pathname)) {
             pathname = fallbackRoute.pathname;
@@ -589,11 +617,14 @@ class FetchState {
    */
   /**
    * Strip `.html` / `/index.html` suffixes from the pathname so the
-   * rendering pipeline sees the canonical route path. Skipped when the
-   * matched route itself has an `.html` extension in its definition.
+   * rendering pipeline sees the canonical route path. Only applies to
+   * page routes where `.html` is framework-injected. Endpoint routes
+   * preserve `.html` because any such suffix is user-provided (e.g.
+   * from `getStaticPaths` params). Skipped when the matched route
+   * itself has an `.html` extension in its definition.
    */
   #stripHtmlExtension() {
-    if (this.routeData && !routeHasHtmlExtension(this.routeData)) {
+    if (this.routeData && this.routeData.type === "page" && !routeHasHtmlExtension(this.routeData)) {
       this.pathname = this.pathname.replace(/\/index\.html$/, "/").replace(/\.html$/, "");
     }
   }
@@ -697,6 +728,12 @@ class FetchState {
         this.clientAddress = forwardedFor;
       }
     }
+    const oldRequest = this.request;
+    this.request = new Request(this.url, oldRequest);
+    const app = Reflect.get(oldRequest, appSymbol);
+    if (app !== void 0) {
+      Reflect.set(this.request, appSymbol, app);
+    }
   }
   /**
    * Returns the resolved `props` for this render, computing them lazily

package/dist/core/i18n/domain.d.ts

@@ -0,0 +1,12 @@
+import type { SSRManifest } from '../app/types.js';
+import type { AstroLogger } from '../logger/core.js';
+/**
+ * For domain-based i18n routing strategies, derives the locale-prefixed
+ * pathname from the request's `Host` header rather than its URL. For example,
+ * a request for `/foo` served from `https://example.fr` resolves to `/fr/foo`.
+ *
+ * Returns `undefined` when the strategy isn't domain-based or the host isn't
+ * mapped to a locale — in which case normal pathname routing applies.
+ *
+ */
+export declare function computePathnameFromDomain(request: Request, url: URL, i18n: SSRManifest['i18n'], base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], logger: AstroLogger): string | undefined;

package/dist/core/i18n/domain.js

@@ -0,0 +1,66 @@
+import {
+  appendForwardSlash,
+  collapseDuplicateLeadingSlashes,
+  joinPaths,
+  prependForwardSlash,
+  removeTrailingForwardSlash
+} from "@astrojs/internal-helpers/path";
+import { normalizeTheLocale } from "../../i18n/index.js";
+function computePathnameFromDomain(request, url, i18n, base, trailingSlash, logger) {
+  let pathname = void 0;
+  if (i18n && (i18n.strategy === "domains-prefix-always" || i18n.strategy === "domains-prefix-other-locales" || i18n.strategy === "domains-prefix-always-no-redirect")) {
+    let host = request.headers.get("X-Forwarded-Host");
+    let protocol = request.headers.get("X-Forwarded-Proto");
+    if (protocol) {
+      protocol = protocol + ":";
+    } else {
+      protocol = url.protocol;
+    }
+    if (!host) {
+      host = request.headers.get("Host");
+    }
+    if (host && protocol) {
+      host = host.split(":")[0];
+      try {
+        let locale;
+        const hostAsUrl = new URL(`${protocol}//${host}`);
+        for (const [domainKey, localeValue] of Object.entries(i18n.domainLookupTable)) {
+          const domainKeyAsUrl = new URL(domainKey);
+          if (hostAsUrl.host === domainKeyAsUrl.host && hostAsUrl.protocol === domainKeyAsUrl.protocol) {
+            locale = localeValue;
+            break;
+          }
+        }
+        if (locale) {
+          pathname = prependForwardSlash(
+            joinPaths(normalizeTheLocale(locale), removeBase(url.pathname, base))
+          );
+          if (trailingSlash === "always") {
+            pathname = appendForwardSlash(pathname);
+          } else if (trailingSlash === "never") {
+            pathname = removeTrailingForwardSlash(pathname);
+          } else if (url.pathname.endsWith("/")) {
+            pathname = appendForwardSlash(pathname);
+          }
+        }
+      } catch (e) {
+        logger.error(
+          "router",
+          `Astro tried to parse ${protocol}//${host} as an URL, but it threw a parsing error. Check the X-Forwarded-Host and X-Forwarded-Proto headers.`
+        );
+        logger.error("router", `Error: ${e}`);
+      }
+    }
+  }
+  return pathname;
+}
+function removeBase(pathname, base) {
+  pathname = collapseDuplicateLeadingSlashes(pathname);
+  if (pathname.startsWith(base)) {
+    return pathname.slice(removeTrailingForwardSlash(base).length + 1);
+  }
+  return pathname;
+}
+export {
+  computePathnameFromDomain
+};

package/dist/core/logger/core.d.ts

@@ -84,7 +84,7 @@ export declare class AstroLogger {
      */
     close(): void;
     /**
-     * It calls the `flush` function of the provided destinatin, if it exists.
+     * It calls the `flush` function of the provided destination, if it exists.
      */
     flush(): void;
 }

package/dist/core/logger/core.js

@@ -136,7 +136,7 @@ class AstroLogger {
     }
   }
   /**
-   * It calls the `flush` function of the provided destinatin, if it exists.
+   * It calls the `flush` function of the provided destination, if it exists.
    */
   flush() {
     if (this.options.destination.flush) {

package/dist/core/messages/runtime.js

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

package/dist/core/routing/create-manifest.js

@@ -677,7 +677,7 @@ function joinSegments(segments) {
   const arr = segments.map((segment) => {
     return segment.map((rp) => rp.dynamic ? `[${rp.content}]` : rp.content).join("");
   });
-  return `/${arr.join("/")}`.toLowerCase();
+  return `/${arr.join("/")}`;
 }
 function replaceOrKeep(original, from, to) {
   if (original.startsWith(`/${to}/`) || original === `/${to}`) return original;

package/dist/core/routing/parse-route.js

@@ -58,7 +58,7 @@ function joinSegments(segments) {
   const arr = segments.map((segment) => {
     return segment.map((part) => part.dynamic ? `[${part.content}]` : part.content).join("");
   });
-  return `/${arr.join("/")}`.toLowerCase();
+  return `/${arr.join("/")}`;
 }
 export {
   parseRoute

package/dist/core/routing/rewrite.js

@@ -101,7 +101,7 @@ function copyRequest(newUrl, oldRequest, isPrerendered, logger, routePattern) {
       signal: oldRequest.signal,
       keepalive: oldRequest.keepalive,
       // https://fetch.spec.whatwg.org/#dom-request-duplex
-      // @ts-expect-error It isn't part of the types, but undici accepts it and it allows to carry over the body to a new request
+      // @ts-expect-error It isn't part of the types, but undici accepts it and it allows carrying over the body to a new request
       duplex: "half"
     }
   });

package/dist/runtime/server/render/head.js

@@ -52,11 +52,7 @@ function renderAllHeadContent(result) {
     (link) => renderElement("link", link, false)
   );
   content += styles.join("\n") + links.join("\n") + scripts.join("\n");
-  if (result._metadata.extraHead.length > 0) {
-    for (const part of result._metadata.extraHead) {
-      content += part;
-    }
-  }
+  content += result._metadata.extraHead.join("");
   return markHTMLString(content);
 }
 function renderHead() {

package/dist/vite-plugin-hmr-reload/index.js

@@ -67,6 +67,9 @@ function hmrReload() {
         if (hasSkippedStyleModules) {
           return [];
         }
+        if (modules.length > 0) {
+          return [];
+        }
       }
     }
   };

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

@@ -26,12 +26,18 @@ function normalizeFilename(filename, root) {
   } else if (filename.startsWith(".")) {
     const url = new URL(filename, root);
     filename = viteID(url);
-  } else if (filename.startsWith("/") && !commonAncestorPath(filename, fileURLToPath(root))) {
+  } else if (filename.startsWith("/") && !isPathInRoot(filename, fileURLToPath(root))) {
     const url = new URL("." + filename, root);
     filename = viteID(url);
   }
   return removeLeadingForwardSlashWindows(filename);
 }
+function isPathInRoot(filename, rootPath) {
+  if (commonAncestorPath(filename, rootPath)) {
+    return true;
+  }
+  return commonAncestorPath(filename.toLowerCase(), rootPath.toLowerCase()) !== "";
+}
 const postfixRE = /[?#].*$/s;
 function cleanUrl(url) {
   return url.replace(postfixRE, "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.4.3",
+  "version": "6.4.5",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",