astro 6.4.2 → 6.4.4

package/dist/assets/fonts/core/optimize-fallbacks.js

@@ -1,4 +1,17 @@
 import { isGenericFontFamily, unifontFontFaceDataToProperties } from "../utils.js";
+function deriveFallbackVariant(data) {
+  const weight = data.weight;
+  if (typeof weight === "number" && weight >= 700) {
+    return "bold";
+  }
+  if (typeof weight === "string") {
+    if (weight === "bold") return "bold";
+    if (weight.includes(" ")) return "normal";
+    const n = Number.parseInt(weight, 10);
+    if (!Number.isNaN(n) && n >= 700) return "bold";
+  }
+  return "normal";
+}
 async function optimizeFallbacks({
   family,
   fallbacks: _fallbacks,
@@ -14,28 +27,40 @@ async function optimizeFallbacks({
   if (!isGenericFontFamily(lastFallback)) {
     return null;
   }
-  const localFonts = systemFallbacksProvider.getLocalFonts(lastFallback);
-  if (!localFonts || localFonts.length === 0) {
+  const collectedWithLocalFonts = collectedFonts.map((collected) => ({
+    collected,
+    localFonts: systemFallbacksProvider.getLocalFonts(lastFallback, deriveFallbackVariant(collected.data)) ?? []
+  }));
+  const uniqueLocalFonts = [];
+  for (const { localFonts } of collectedWithLocalFonts) {
+    for (const font of localFonts) {
+      if (!uniqueLocalFonts.includes(font)) {
+        uniqueLocalFonts.push(font);
+      }
+    }
+  }
+  if (uniqueLocalFonts.length === 0) {
     return null;
   }
-  if (localFonts.includes(family.name)) {
+  if (uniqueLocalFonts.includes(family.name)) {
     return null;
   }
-  const localFontsMappings = localFonts.map((font) => ({
-    font,
+  const nameForFont = (font) => (
     // We mustn't wrap in quote because that's handled by the CSS renderer
-    name: `${family.uniqueName} fallback: ${font}`
-  }));
-  fallbacks = [...localFontsMappings.map((m) => m.name), ...fallbacks];
+    `${family.uniqueName} fallback: ${font}`
+  );
+  fallbacks = [...uniqueLocalFonts.map(nameForFont), ...fallbacks];
   let css = "";
-  for (const { font, name } of localFontsMappings) {
-    for (const collected of collectedFonts) {
+  for (const { collected, localFonts } of collectedWithLocalFonts) {
+    const properties = unifontFontFaceDataToProperties(collected.data);
+    const metrics = await fontMetricsResolver.getMetrics(family.name, collected);
+    for (const font of localFonts) {
       css += fontMetricsResolver.generateFontFace({
-        metrics: await fontMetricsResolver.getMetrics(family.name, collected),
+        metrics,
         fallbackMetrics: systemFallbacksProvider.getMetricsForLocalFont(font),
         font,
-        name,
-        properties: unifontFontFaceDataToProperties(collected.data)
+        name: nameForFont(font),
+        properties
       });
     }
   }

package/dist/assets/fonts/definitions.d.ts

@@ -1,6 +1,6 @@
 import type * as unifont from 'unifont';
 import type { CollectedFontForMetrics } from './core/optimize-fallbacks.js';
-import type { CssProperties, FontFaceMetrics, FontFileData, FontProvider, FontType, GenericFallbackName, ResolveFontOptions, Style } from './types.js';
+import type { CssProperties, FallbackVariant, FontFaceMetrics, FontFileData, FontProvider, FontType, GenericFallbackName, ResolveFontOptions, Style } from './types.js';
 export interface Hasher {
     hashString: (input: string) => string;
     hashObject: (input: Record<string, any>) => string;
@@ -28,7 +28,7 @@ export interface FontMetricsResolver {
     }) => string;
 }
 export interface SystemFallbacksProvider {
-    getLocalFonts: (fallback: GenericFallbackName) => Array<string> | null;
+    getLocalFonts: (fallback: GenericFallbackName, variant: FallbackVariant) => Array<string> | null;
     getMetricsForLocalFont: (family: string) => FontFaceMetrics;
 }
 export interface FontFetcher {

package/dist/assets/fonts/infra/system-fallbacks-provider.d.ts

@@ -1,6 +1,6 @@
 import type { SystemFallbacksProvider } from '../definitions.js';
-import type { FontFaceMetrics, GenericFallbackName } from '../types.js';
+import type { FallbackVariant, FontFaceMetrics, GenericFallbackName } from '../types.js';
 export declare class RealSystemFallbacksProvider implements SystemFallbacksProvider {
-    getLocalFonts(fallback: GenericFallbackName): Array<string> | null;
+    getLocalFonts(fallback: GenericFallbackName, variant: FallbackVariant): Array<string> | null;
     getMetricsForLocalFont(family: string): FontFaceMetrics;
 }

package/dist/assets/fonts/infra/system-fallbacks-provider.js

@@ -6,6 +6,14 @@ const SYSTEM_METRICS = {
     unitsPerEm: 2048,
     xWidthAvg: 832
   },
+  "Times New Roman Bold": {
+    ascent: 1825,
+    descent: -443,
+    lineGap: 87,
+    unitsPerEm: 2048,
+    xWidthAvg: 886
+  },
+  // Times New Roman Italic almost has the same properties as Times New Roman, we don't include it
   Arial: {
     ascent: 1854,
     descent: -434,
@@ -13,6 +21,14 @@ const SYSTEM_METRICS = {
     unitsPerEm: 2048,
     xWidthAvg: 913
   },
+  "Arial Bold": {
+    ascent: 1854,
+    descent: -434,
+    lineGap: 67,
+    unitsPerEm: 2048,
+    xWidthAvg: 983
+  },
+  // Arial Italic has the same properties as Arial, we don't include it
   "Courier New": {
     ascent: 1705,
     descent: -615,
@@ -20,6 +36,8 @@ const SYSTEM_METRICS = {
     unitsPerEm: 2048,
     xWidthAvg: 1229
   },
+  // Courier New Bold has the same properties as Courier New, we don't include it
+  // Courier New Italic has the same properties as Courier New, we don't include it
   BlinkMacSystemFont: {
     ascent: 1980,
     descent: -432,
@@ -50,17 +68,36 @@ const SYSTEM_METRICS = {
   }
 };
 const DEFAULT_FALLBACKS = {
-  serif: ["Times New Roman"],
-  "sans-serif": ["Arial"],
-  monospace: ["Courier New"],
-  "system-ui": ["BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial"],
-  "ui-serif": ["Times New Roman"],
-  "ui-sans-serif": ["Arial"],
-  "ui-monospace": ["Courier New"]
+  serif: {
+    normal: ["Times New Roman"],
+    bold: ["Times New Roman Bold"]
+  },
+  "sans-serif": {
+    normal: ["Arial"],
+    bold: ["Arial Bold"]
+  },
+  monospace: { normal: ["Courier New"] },
+  "system-ui": {
+    normal: ["BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial"],
+    bold: ["BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial Bold"]
+  },
+  "ui-serif": {
+    normal: ["Times New Roman"],
+    bold: ["Times New Roman Bold"]
+  },
+  "ui-sans-serif": {
+    normal: ["Arial"],
+    bold: ["Arial Bold"]
+  },
+  "ui-monospace": { normal: ["Courier New"] }
 };
 class RealSystemFallbacksProvider {
-  getLocalFonts(fallback) {
-    return DEFAULT_FALLBACKS[fallback] ?? null;
+  getLocalFonts(fallback, variant) {
+    const entry = DEFAULT_FALLBACKS[fallback];
+    if (!entry) {
+      return null;
+    }
+    return entry[variant] ?? entry.normal ?? null;
   }
   getMetricsForLocalFont(family) {
     return SYSTEM_METRICS[family];

package/dist/assets/fonts/types.d.ts

@@ -191,6 +191,7 @@ export interface PreloadData {
 }
 export type FontFaceMetrics = Pick<Font, 'ascent' | 'descent' | 'lineGap' | 'unitsPerEm' | 'xWidthAvg'>;
 export type GenericFallbackName = (typeof GENERIC_FALLBACK_NAMES)[number];
+export type FallbackVariant = 'normal' | 'bold';
 export type Defaults = Required<Pick<ResolvedFontFamily, 'weights' | 'styles' | 'subsets' | 'fallbacks' | 'optimizedFallbacks' | 'formats'>>;
 export interface FontFileData {
     id: string;

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.2";
+  version = "6.4.4";
 }
 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.2") {
+    if (previousAstroVersion && previousAstroVersion !== "6.4.4") {
       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.2") {
-      this.#store.metaStore().set("astro-version", "6.4.2");
+    if ("6.4.4") {
+      this.#store.metaStore().set("astro-version", "6.4.4");
     }
     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";
@@ -117,19 +115,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 +154,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 +179,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 +227,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/base-pipeline.d.ts

@@ -29,6 +29,9 @@ export declare const PipelineFeatures: {
     readonly i18n: number;
     readonly cache: number;
 };
+/** All feature bits ORed together. Keep next to `PipelineFeatures` so
+ *  new flags are hard to forget. */
+export declare const ALL_PIPELINE_FEATURES: number;
 /**
  * The `Pipeline` represents the static parts of rendering that do not change between requests.
  * These are mostly known when the server first starts up and do not change.

package/dist/core/base-pipeline.js

@@ -21,6 +21,7 @@ const PipelineFeatures = {
   i18n: 1 << 4,
   cache: 1 << 5
 };
+const ALL_PIPELINE_FEATURES = PipelineFeatures.redirects | PipelineFeatures.sessions | PipelineFeatures.actions | PipelineFeatures.middleware | PipelineFeatures.i18n | PipelineFeatures.cache;
 class Pipeline {
   internalMiddleware;
   resolvedMiddleware = void 0;
@@ -295,6 +296,7 @@ class Pipeline {
   }
 }
 export {
+  ALL_PIPELINE_FEATURES,
   Pipeline,
   PipelineFeatures
 };

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.4.2";
+const ASTRO_VERSION = "6.4.4";
 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.2";
+  const currentVersion = "6.4.4";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

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

@@ -10,7 +10,6 @@ import { AstroCookies } from "../cookies/index.js";
 import { Slots } from "../render/index.js";
 import {
   ASTRO_GENERATOR,
-  DEFAULT_404_COMPONENT,
   fetchStateSymbol,
   originPathnameSymbol,
   pipelineSymbol,
@@ -30,7 +29,8 @@ 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 { routeHasHtmlExtension } from "../routing/helpers.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";
 function getFetchStateFromAPIContext(context) {
@@ -137,6 +137,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. */
@@ -159,7 +166,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 ?? {};
@@ -422,10 +446,8 @@ class FetchState {
     }
     return {
       insertDirective(payload) {
-        if (state?.result?.directives) {
+        if (state.result) {
           state.result.directives = pushDirective(state.result.directives, payload);
-        } else {
-          state?.result?.directives.push(payload);
         }
       },
       insertScriptResource(resource) {
@@ -465,7 +487,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;
@@ -592,11 +616,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$/, "");
     }
   }
@@ -620,9 +647,10 @@ class FetchState {
     pipeline.logger.debug("router", "Astro matched the following route for " + this.request.url);
     pipeline.logger.debug("router", "RouteData:\n" + this.routeData);
     if (!this.routeData) {
-      this.routeData = pipeline.manifestData.routes.find(
-        (route) => route.component === "404.astro" || route.component === DEFAULT_404_COMPONENT
-      );
+      const custom404 = getCustom404Route(pipeline.manifestData);
+      if (custom404 && !custom404.prerender) {
+        this.routeData = custom404;
+      }
     }
     if (!this.routeData) {
       pipeline.logger.debug("router", "Astro hasn't found routes that match " + this.request.url);

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

@@ -37,6 +37,9 @@ class I18n {
     state.pipeline.usedFeatures |= PipelineFeatures.i18n;
     const i18n = this.#i18n;
     const typeHeader = response.headers.get(ROUTE_TYPE_HEADER);
+    if (typeHeader) {
+      response.headers.delete(ROUTE_TYPE_HEADER);
+    }
     const isReroute = response.headers.get(REROUTE_DIRECTIVE_HEADER);
     if (isReroute === "no" && typeof i18n.fallback === "undefined") {
       return response;

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.2"}`
+        `v${"6.4.4"}`
       )} ${headline}`
     );
   }

package/dist/core/middleware/astro-middleware.js

@@ -1,5 +1,4 @@
 import { PipelineFeatures } from "../base-pipeline.js";
-import { ROUTE_TYPE_HEADER } from "../constants.js";
 import { attachCookiesToResponse } from "../cookies/index.js";
 import { applyRewriteToState } from "../rewrites/handler.js";
 import { callMiddleware } from "./callMiddleware.js";
@@ -43,9 +42,6 @@ class AstroMiddleware {
     return response;
   }
   #finalize(state, response) {
-    if (response.headers.get(ROUTE_TYPE_HEADER)) {
-      response.headers.delete(ROUTE_TYPE_HEADER);
-    }
     attachCookiesToResponse(response, state.cookies);
     return response;
   }

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/handler.js

@@ -12,7 +12,7 @@ import { PagesHandler } from "../pages/handler.js";
 import { renderRedirect } from "../redirects/render.js";
 import { provideSession } from "../session/handler.js";
 import { prepareResponse } from "../app/prepare-response.js";
-import { PipelineFeatures } from "../base-pipeline.js";
+import { ALL_PIPELINE_FEATURES, PipelineFeatures } from "../base-pipeline.js";
 class AstroHandler {
   #app;
   #trailingSlashHandler;
@@ -64,6 +64,7 @@ class AstroHandler {
     return this.#pagesHandler.handle(state, ctx);
   }
   async handle(state) {
+    state.pipeline.usedFeatures |= ALL_PIPELINE_FEATURES;
     const trailingSlashRedirect = this.#trailingSlashHandler.handle(state);
     if (trailingSlashRedirect) {
       return trailingSlashRedirect;

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/client/dev-toolbar/apps/audit/rules/a11y.js

@@ -25,6 +25,14 @@
 import { aria, roles } from "aria-query";
 import { AXObjectRoles, elementAXObjects } from "axobject-query";
 const WHITESPACE_REGEX = /\s+/;
+function isHiddenByClosedDetails(element) {
+  for (let parent = element.parentElement; parent; parent = parent.parentElement) {
+    if (parent.localName !== "details" || parent.open) continue;
+    const summary = Array.from(parent.children).find((child) => child.localName === "summary");
+    if (!summary?.contains(element)) return true;
+  }
+  return false;
+}
 const a11y_required_attributes = {
   a: ["href"],
   area: ["alt", "aria-label", "aria-labelledby"],
@@ -321,6 +329,7 @@ const a11y = [
     message: "Headings and anchors must have an accessible name, which can come from: inner text, aria-label, aria-labelledby, an img with alt property, or an svg with a tag <title></title>.",
     selector: a11y_required_content.join(","),
     match(element) {
+      if (isHiddenByClosedDetails(element)) return false;
       const innerText = element.innerText?.trim();
       if (innerText && innerText !== "") return false;
       const ariaLabel = element.getAttribute("aria-label")?.trim();

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/runtime/server/render/util.js

@@ -149,7 +149,7 @@ class BufferedRenderer {
 function createBufferedRenderer(destination, renderFunction) {
   return new BufferedRenderer(destination, renderFunction);
 }
-const isNode = typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]";
+const isNode = typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]" && !(typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers");
 const isDeno = typeof Deno !== "undefined";
 function promiseWithResolvers() {
   let resolve, reject;

package/dist/virtual-modules/i18n.d.ts

@@ -207,9 +207,9 @@ export type I18nMiddlewareOptions = {
 /**
  * @param {AstroConfig['i18n']['routing']} customOptions
  *
- * A function that allows to programmatically create the Astro i18n middleware.
+ * A function that allows you to programmatically create the Astro i18n middleware.
  *
- * This is use useful when you still want to use the default i18n logic, but add only few exceptions to your website.
+ * This is useful when you still want to use the default i18n logic, but add only a few exceptions to your website.
  *
  * ## Examples
  *

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.2",
+  "version": "6.4.4",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -124,7 +124,7 @@
     "clsx": "^2.1.1",
     "common-ancestor-path": "^2.0.0",
     "cookie": "^1.1.1",
-    "devalue": "^5.6.3",
+    "devalue": "^5.8.1",
     "diff": "^8.0.3",
     "dset": "^3.1.4",
     "es-module-lexer": "^2.0.0",