Update astro monorepo

[renovate]

This PR contains the following updates:

Package	Change	Age	Confidence
@astrojs/cloudflare (source)	12.6.10 → 12.6.12
@astrojs/vue (source)	5.1.3 → 5.1.4
astro (source)	5.15.5 → 5.16.15

---

Release Notes

withastro/astro (@​astrojs/cloudflare)

v12.6.12

Compare Source

Patch Changes

• #​14777 9720b70 Thanks @​iclectic! - Updates assets handling to use @astrojs/internal-helpers

• Updated dependencies []:

  • @​astrojs/underscore-redirects@​1.0.0

v12.6.11

Compare Source

Patch Changes

• Updated dependencies [9e9c528, 0f75f6b]:
  • @​astrojs/internal-helpers@​0.7.5
  • @​astrojs/underscore-redirects@​1.0.0

withastro/astro (@​astrojs/vue)

v5.1.4

Compare Source

Patch Changes

• #​15016 12eb4cd Thanks @​rahuld109! - Adds support for arbitrary HTML attributes on Vue components

withastro/astro (astro)

v5.16.15

Compare Source

Patch Changes

• #​15286 0aafc83 Thanks @​florian-lefebvre! - Fixes a case where font providers provided as class instances may not work when using the experimental Fonts API. It affected the local provider

v5.16.14

Compare Source

Patch Changes

• #​15213 c775fce Thanks @​florian-lefebvre! - BREAKING CHANGE to the experimental Fonts API only

  Updates how the local provider must be used when using the experimental Fonts API

  Previously, there were 2 kinds of font providers: remote and local.

  Font providers are now unified. If you are using the local provider, the process for configuring local fonts must be updated:

  -import { defineConfig } from "astro/config";
  +import { defineConfig, fontProviders } from "astro/config";
  
  export default defineConfig({
      experimental: {
          fonts: [{
              name: "Custom",
              cssVariable: "--font-custom",
  -            provider: "local",
  +            provider: fontProviders.local(),
  +            options: {
              variants: [
                  {
                      weight: 400,
                      style: "normal",
                      src: ["./src/assets/fonts/custom-400.woff2"]
                  },
                  {
                      weight: 700,
                      style: "normal",
                      src: ["./src/assets/fonts/custom-700.woff2"]
                  }
                  // ...
              ]
  +            }
          }]
      }
  });

  Once configured, there is no change to using local fonts in your project. However, you should inspect your deployed site to confirm that your new font configuration is being applied.

  See the experimental Fonts API docs for more information.

• #​15213 c775fce Thanks @​florian-lefebvre! - Exposes root on FontProvider init() context

  When building a custom FontProvider for the experimental Fonts API, the init() method receives a context. This context now exposes a root URL, useful for resolving local files:

  import type { FontProvider } from "astro";
  
  export function registryFontProvider(): FontProvider {
    return {
      // ...
  -    init: async ({ storage }) => {
  +    init: async ({ storage, root }) => {
          // ...
      },
    };
  }

• #​15185 edabeaa Thanks @​EricGrill! - Add .vercel to .gitignore when adding the Vercel adapter via astro add vercel

v5.16.13

Compare Source

Patch Changes

• #​15182 cb60ee1 Thanks @​florian-lefebvre! - Adds a new getFontBuffer() method to retrieve font file buffers when using the experimental Fonts API

  The getFontData() helper function from astro:assets was introduced in 5.14.0 to provide access to font family data for use outside of Astro. One of the goals of this API was to be able to retrieve buffers using URLs.

  However, it turned out to be impactical and even impossible during prerendering.

  Astro now exports a new getFontBuffer() helper function from astro:assets to retrieve font file buffers from URL returned by getFontData(). For example, when using satori to generate OpenGraph images:

  // src/pages/og.png.ts
  
  import type{ APIRoute } from "astro"
  -import { getFontData } from "astro:assets"
  +import { getFontData, getFontBuffer } from "astro:assets"
  import satori from "satori"
  
  export const GET: APIRoute = (context) => {
    const data = getFontData("--font-roboto")
  
    const svg = await satori(
      <div style={{ color: "black" }}>hello, world</div>,
      {
        width: 600,
        height: 400,
        fonts: [
          {
            name: "Roboto",
  -          data: await fetch(new URL(data[0].src[0].url, context.url.origin)).then(res => res.arrayBuffer()),
  +          data: await getFontBuffer(data[0].src[0].url),
            weight: 400,
            style: "normal",
          },
        ],
      },
    )
  
    // ...
  }

  See the experimental Fonts API documentation for more information.

v5.16.12

Compare Source

Patch Changes

• #​15175 47ae148 Thanks @​florian-lefebvre! - Allows experimental Font providers to specify family options

  Previously, an Astro FontProvider could only accept options at the provider level when called. That could result in weird data structures for family-specific options.

  Astro FontProviders can now declare family-specific options, by specifying a generic:

  // font-provider.ts
  import type { FontProvider } from "astro";
  import { retrieveFonts, type Fonts } from "./utils.js",
  
  interface Config {
    token: string;
  }
  
  +interface FamilyOptions {
  +    minimal?: boolean;
  +}
  
  -export function registryFontProvider(config: Config): FontProvider {
  +export function registryFontProvider(config: Config): FontProvider<FamilyOptions> {
    let data: Fonts = {}
  
    return {
      name: "registry",
      config,
      init: async () => {
        data = await retrieveFonts(token);
      },
      listFonts: () => {
        return Object.keys(data);
      },
  -    resolveFont: ({ familyName, ...rest }) => {
  +    // options is typed as FamilyOptions
  +    resolveFont: ({ familyName, options, ...rest }) => {
        const fonts = data[familyName];
        if (fonts) {
          return { fonts };
        }
        return undefined;
      },
    };
  }

  Once the font provider is registered in the Astro config, types are automatically inferred:

  // astro.config.ts
  import { defineConfig } from "astro/config";
  import { registryFontProvider } from "./font-provider";
  
  export default defineConfig({
      experimental: {
          fonts: [{
              provider: registryFontProvider({
                token: "..."
              }),
              name: "Custom",
              cssVariable: "--font-custom",
  +            options: {
  +                minimal: true
  +            }
          }]
      }
  });

• #​15175 47ae148 Thanks @​florian-lefebvre! - BREAKING CHANGE to the experimental Fonts API only

  Updates how options are passed to the Google and Google Icons font providers when using the experimental Fonts API

  Previously, the Google and Google Icons font providers accepted options that were specific to given font families.

  These options must now be set using the options property instead. For example using the Google provider:

  import { defineConfig, fontProviders } from "astro/config";
  
  export default defineConfig({
      experimental: {
          fonts: [{
              name: 'Inter',
              cssVariable: '--astro-font-inter',
              weights: ['300 900'],
  -            provider: fontProviders.google({
  -                experimental: {
  -                    variableAxis: {
  -                        Inter: { opsz: ['14..32'] }
  -                    }
  -                }
  -            }),
  +            provider: fontProviders.google(),
  +            options: {
  +                experimental: {
  +                    variableAxis: { opsz: ['14..32'] }
  +                }
  +            }
          }]
      }
  })

• #​15200 c0595b3 Thanks @​florian-lefebvre! - BREAKING CHANGE to the experimental Fonts API only

  Removes getFontData() exported from astro:assets with fontData when using the experimental Fonts API

  Accessing font data can be useful for advanced use cases, such as generating meta tags or Open Graph images. Before, we exposed a getFontData() helper function to retrieve the font data for a given cssVariable. That was however limiting for programmatic usages that need to access all font data.

  The getFontData() helper function is removed and replaced by a new fontData object:

  -import { getFontData } from "astro:assets";
  -const data = getFontData("--font-roboto")
  
  +import { fontData } from "astro:assets";
  +const data = fontData["--font-roboto"]

  We may reintroduce getFontData() later on for a more friendly DX, based on your feedback.

• #​15254 8d84b30 Thanks @​lamalex! - Fixes CSS assetsPrefix with remote URLs incorrectly prepending a forward slash

  When using build.assetsPrefix with a remote URL (e.g., https://cdn.example.com) for CSS assets, the generated <link> elements were incorrectly getting a / prepended to the full URL, resulting in invalid URLs like /https://cdn.example.com/assets/style.css.

  This fix checks if the stylesheet link is a remote URL before prepending the forward slash.

• #​15178 731f52d Thanks @​kedarvartak! - Fixes an issue where stopping the dev server with q+enter incorrectly created a dist folder and copied font files when using the experimental Fonts API

• #​15230 3da6272 Thanks @​rahuld109! - Fixes greedy regex in error message markdown rendering that caused link syntax examples to capture extra characters

• #​15253 2a6315a Thanks @​matthewp! - Fixes hydration for React components nested inside HTML elements in MDX files

• #​15227 9a609f4 Thanks @​matthewp! - Fixes styles not being included for conditionally rendered Svelte 5 components in production builds

• #​14607 ee52160 Thanks @​simensfo! - Reintroduces css deduplication for hydrated client components. Ensures assets already added to a client chunk are not flagged as orphaned

v5.16.11

Compare Source

Patch Changes

• #​15017 9e7a3c8 Thanks @​ixchio! - Fixes CSS double-bundling when the same CSS file is imported in both a page's frontmatter and a component's script tag

• #​15225 6fe62e1 Thanks @​ematipico! - Updates to the latest version of devalue

v5.16.10

Compare Source

Patch Changes

• 2fa19c4 - Improved error handling in the rendering phase

  Added defensive validation in App.render() and #renderError() to provide a descriptive error message when a route module doesn't have a valid page function.

• #​15199 d8e64ef Thanks @​ArmandPhilippot! - Fixes the links to Astro Docs so that they match the current docs structure.

• #​15169 b803d8b Thanks @​rururux! - fix: fix image 500 error when moving dist directory in standalone Node

• #​14622 9b35c62 Thanks @​aprici7y! - Fixes CSS url() references to public assets returning 404 in dev mode when base path is configured

• #​15219 43df4ce Thanks @​matthewp! - Upgrades the diff package to v8

v5.16.9

Compare Source

Patch Changes

• #​15174 37ab65a Thanks @​florian-lefebvre! - Adds Google Icons to built-in font providers

  To start using it, access it on fontProviders:

  import { defineConfig, fontProviders } from 'astro/config';
  
  export default defineConfig({
    experimental: {
      fonts: [
        {
          name: 'Material Symbols Outlined',
          provider: fontProviders.googleicons(),
          cssVariable: '--font-material',
        },
      ],
    },
  });

• #​15150 a77c4f4 Thanks @​matthewp! - Fixes hydration for framework components inside MDX when using Astro.slots.render()

  Previously, when multiple framework components with client:* directives were passed as named slots to an Astro component in MDX, only the first slot would hydrate correctly. Subsequent slots would render their HTML but fail to include the necessary hydration scripts.

• #​15130 9b726c4 Thanks @​florian-lefebvre! - BREAKING CHANGE to the experimental Fonts API only

  Changes how font providers are implemented with updates to the FontProvider type

  This is an implementation detail that changes how font providers are created. This process allows Astro to take more control rather than relying directly on unifont types. All of Astro's built-in font providers have been updated to reflect this new type, and can be configured as before. However, using third-party unifont providers that rely on unifont types will require an update to your project code.

  Previously, an Astro FontProvider was made of a config and a runtime part. It relied directly on unifont types, which allowed a simple configuration for third-party unifont providers, but also coupled Astro's implementation to unifont, which was limiting.

  Astro's font provider implementation is now only made of a config part with dedicated hooks. This allows for the separation of config and runtime, but requires you to create a font provider object in order to use custom font providers (e.g. third-party unifont providers, or private font registeries).

What should I do?

If you were using a 3rd-party unifont font provider, you will now need to write an Astro FontProvider using it under the hood. For example:

// astro.config.ts
import { defineConfig } from "astro/config";
import { acmeProvider, type AcmeOptions } from '@​acme/unifont-provider'
+import type { FontProvider } from "astro";
+import type { InitializedProvider } from 'unifont';

+function acme(config?: AcmeOptions): FontProvider {
+	const provider = acmeProvider(config);
+	let initializedProvider: InitializedProvider | undefined;
+	return {
+		name: provider._name,
+		config,
+		async init(context) {
+			initializedProvider = await provider(context);
+		},
+		async resolveFont({ familyName, ...rest }) {
+			return await initializedProvider?.resolveFont(familyName, rest);
+		},
+		async listFonts() {
+			return await initializedProvider?.listFonts?.();
+		},
+	};
+}

export default defineConfig({
    experimental: {
        fonts: [{
-            provider: acmeProvider({ /* ... */ }),
+            provider: acme({ /* ... */ }),
            name: "Material Symbols Outlined",
            cssVariable: "--font-material"
        }]
    }
});

• #​15147 9cd5b87 Thanks @​matthewp! - Fixes scripts in components not rendering when a sibling <Fragment slot="..."> exists but is unused

v5.16.8

Compare Source

Patch Changes

• #​15124 81db3c0 Thanks @​leonace924! - Fixes an issue where requests with query parameters to the base path would return a 404 if trailingSlash was not 'ignore' in development

• #​15152 39ee41f Thanks @​rururux! - Fixes a case where context.cookies.set() would be overriden when setting cookies via response headers in development

• #​15140 6f6f8f8 Thanks @​cameronraysmith! - Fixes esbuild warning due to dead code in assets virtual module

• #​15127 2cff904 Thanks @​Princesseuh! - Updates "Unsupported page types found" error to only appear in more realistic cases

• #​15149 34f84c2 Thanks @​rahuld109! - Skips "Use the Image component" audit warning for images inside framework components (React, Vue, Svelte, etc.)

v5.16.7

Compare Source

Patch Changes

• #​15122 b137946 Thanks @​florian-lefebvre! - Improves JSDoc annotations for AstroGlobal, AstroSharedContext and APIContext types

• #​15123 3f58fa2 Thanks @​43081j! - Improves rendering performance by grouping render chunks when emitting from async iterables to avoid encoding costs

• #​14954 7bec4bd Thanks @​volpeon! - Fixes remote images Etag header handling by disabling internal cache

• #​15052 b2bcd5a Thanks @​Princesseuh! - Fixes images not working in development when using setups with port forwarding

• #​15028 87b19b8 Thanks @​Princesseuh! - Fixes certain aliases not working when using images in JSON files with the content layer

• #​15118 cfa382b Thanks @​florian-lefebvre! - BREAKING CHANGE to the experimental Fonts API only

  Removes the defineAstroFontProvider() type helper.

  If you are building a custom font provider, remove any occurrence of defineAstroFontProvider() and use the FontProvider type instead:

  -import { defineAstroFontProvider } from 'astro/config';
  
  -export function myProvider() {
  -    return defineAstroFontProvider({
  -        entrypoint: new URL('./implementation.js', import.meta.url)
  -    });
  -};
  
  +import type { FontProvider } from 'astro';
  
  +export function myProvider(): FontProvider {
  +    return {
  +        entrypoint: new URL('./implementation.js', import.meta.url)
  +    },
  +}

• #​15055 4e28db8 Thanks @​delucis! - Reduces Astro’s install size by around 8 MB

• #​15088 a19140f Thanks @​martrapp! - Enables the ClientRouter to preserve the original hash part of the target URL during server side redirects.

• #​15117 b1e8e32 Thanks @​florian-lefebvre! - BREAKING CHANGE to the experimental Fonts API only

  Changes the font format downloaded by default when using the experimental Fonts API. Additionally, adds a new formats configuration option to specify which font formats to download.

  Previously, Astro was opinionated about which font sources would be kept for usage, mainly keeping woff2 and woff files.

  You can now specify what font formats should be downloaded (if available). Only woff2 files are downloaded by default.

What should I do?

If you were previously relying on Astro downloading the woff format, you will now need to specify this explicitly with the new formats configuration option. Additionally, you may also specify any additional file formats to download if available:

// astro.config.mjs
import { defineConfig, fontProviders } from 'astro/config'

export default defineConfig({
    experimental: {
        fonts: [{
            name: 'Roboto',
            cssVariable: '--font-roboto',
            provider: fontProviders.google(),
+            formats: ['woff2', 'woff', 'otf']
        }]
    }
})

• #​15034 8115752 Thanks @​florian-lefebvre! - Fixes a vite warning log during builds when using npm

v5.16.6

Compare Source

Patch Changes

• #​14982 6849e38 Thanks @​Princesseuh! - Fixes images outside the project directory not working when using astro:assets in development mode

• #​14987 9dd9fca Thanks @​Princesseuh! - Fixes SVGs not working in dev mode when using the passthrough image service

• #​15014 a178422 Thanks @​delucis! - Adds support for extending the type of the props accepted by Astro’s <Image> component, <Picture> component, and getImage() API.

v5.16.5

Compare Source

Patch Changes

• #​14985 c016f10 Thanks @​florian-lefebvre! - Fixes a case where JSDoc annotations wouldn't show for fonts related APIs in the Astro config

• #​14973 ed7cc2f Thanks @​amankumarpandeyin! - Fixes performance regression and OOM errors when building medium-sized blogs with many content entries. Replaced O(n²) object spread pattern with direct mutation in generateLookupMap.

• #​14958 70eb542 Thanks @​ascorbic! - Gives a helpful error message if a user sets output: "hybrid" in their Astro config.

  The option was removed in Astro 5, but lots of content online still references it, and LLMs often suggest it. It's not always clear that the replacement is output: "static", rather than output: "server". This change adds a helpful error message to guide humans and robots.

• #​14901 ef53716 Thanks @​Darknab! - Updates the glob() loader to log a warning when duplicated IDs are detected

• Updated dependencies [d8305f8]:

  • @​astrojs/markdown-remark@​6.3.10

v5.16.4

Compare Source

Patch Changes

• #​14940 2cf79c2 Thanks @​ematipico! - Fixes a bug where Astro didn't properly combine CSP resources from the csp configuration with those added using the runtime API (Astro.csp.insertDirective()) to form grammatically correct CSP headers

  Now Astro correctly deduplicate CSP resources. For example, if you have a global resource in the configuration file, and then you add a
  a new one using the runtime APIs.

v5.16.3

Compare Source

Patch Changes

• #​14889 4bceeb0 Thanks @​florian-lefebvre! - Fixes actions types when using specific TypeScript configurations

• #​14929 e0f277d Thanks @​matthewp! - Fixes authentication bypass via double URL encoding in middleware

  Prevents attackers from bypassing path-based authentication checks using multi-level URL encoding (e.g., /%2561dmin instead of /%61dmin). Pathnames are now validated after decoding to ensure no additional encoding remains.

v5.16.2

Compare Source

Patch Changes

• #​14876 b43dc7f Thanks @​florian-lefebvre! - Fixes a vite warning log during builds when using npm

• #​14884 10273e0 Thanks @​florian-lefebvre! - Fixes a case where setting the status of a page to 404 in ssr would show an empty page (or 404.astro page if provided) instead of using the current page

v5.16.1

Compare Source

Patch Changes

• #​14769 b43ee71 Thanks @​adriandlam! - Fixes an unhandled rejection issue when using Astro with Vercel Workflow DevKit

• #​14761 345eb22 Thanks @​ooga! - Updates button attributes types to allow command and commandfor

• #​14866 65e214b Thanks @​GameRoMan! - Fixes Astro.glob to be correctly marked as deprecated

• #​14894 1ad9a5b Thanks @​delucis! - Fixes support for Astro component rendering in Vitest test suites using a “client” environment such as happy-dom or jsdom

• #​14782 abed929 Thanks @​florian-lefebvre! - Improves syncing

v5.16.0

Compare Source

Minor Changes

• #​13880 1a2ed01 Thanks @​azat-io! - Adds experimental SVGO optimization support for SVG assets

  Astro now supports automatic SVG optimization using SVGO during build time. This experimental feature helps reduce SVG file sizes while maintaining visual quality, improving your site's performance.

  To enable SVG optimization with default settings, add the following to your astro.config.mjs:

  import { defineConfig } from 'astro/config';
  
  export default defineConfig({
    experimental: {
      svgo: true,
    },
  });

  To customize optimization, pass a SVGO configuration object:

  export default defineConfig({
    experimental: {
      svgo: {
        plugins: [
          'preset-default',
          {
            name: 'removeViewBox',
            active: false,
          },
        ],
      },
    },
  });

  For more information on enabling and using this feature in your project, see the experimental SVG optimization docs.

• #​14810 2e845fe Thanks @​ascorbic! - Adds a hint for code agents to use the --yes flag to skip prompts when running astro add

• #​14698 f42ff9b Thanks @​mauriciabad! - Adds the ActionInputSchema utility type to automatically infer the TypeScript type of an action's input based on its Zod schema

  For example, this type can be used to retrieve the input type of a form action:

  import { type ActionInputSchema, defineAction } from 'astro:actions';
  import { z } from 'astro/zod';
  
  const action = defineAction({
    accept: 'form',
    input: z.object({ name: z.string() }),
    handler: ({ name }) => ({ message: `Welcome, ${name}!` }),
  });
  
  type Schema = ActionInputSchema<typeof action>;
  // typeof z.object({ name: z.string() })
  
  type Input = z.input<Schema>;
  // { name: string }

• #​14574 4356485 Thanks @​jacobdalamb! - Adds new CLI shortcuts available when running astro preview:

  • o + enter: open the site in your browser
  • q + enter: quit the preview
  • h + enter: print all available shortcuts

Patch Changes

• #​14813 e1dd377 Thanks @​ematipico! - Removes picocolors as dependency in favor of the fork piccolore.

• #​14609 d774306 Thanks @​florian-lefebvre! - Improves astro info

• #​14796 c29a785 Thanks @​florian-lefebvre! - BREAKING CHANGE to the experimental Fonts API only

  Updates the default subsets to ["latin"]

  Subsets have been a common source of confusion: they caused a lot of files to be downloaded by default. You now have to manually pick extra subsets.

  Review your Astro config and update subsets if you need, for example if you need greek characters:

  import { defineConfig, fontProviders } from "astro/config"
  
  export default defineConfig({
      experimental: {
          fonts: [{
              name: "Roboto",
              cssVariable: "--font-roboto",
              provider: fontProviders.google(),
  +            subsets: ["latin", "greek"]
          }]
      }
  })

v5.15.9

Compare Source

Patch Changes

• #​14786 758a891 Thanks @​mef! - Add handling of invalid encrypted props and slots in server islands.

• #​14783 504958f Thanks @​florian-lefebvre! - Improves the experimental Fonts API build log to show the number of downloaded files. This can help spotting excessive downloading because of misconfiguration

• #​14791 9e9c528 Thanks @​Princesseuh! - Changes the remote protocol checks for images to require explicit authorization in order to use data URIs.

  In order to allow data URIs for remote images, you will need to update your astro.config.mjs file to include the following configuration:

  // astro.config.mjs
  import { defineConfig } from 'astro/config';
  
  export default defineConfig({
    images: {
      remotePatterns: [
        {
          protocol: 'data',
        },
      ],
    },
  });

• #​14787 0f75f6b Thanks @​matthewp! - Fixes wildcard hostname pattern matching to correctly reject hostnames without dots

  Previously, hostnames like localhost or other single-part names would incorrectly match patterns like *.example.com. The wildcard matching logic has been corrected to ensure that only valid subdomains matching the pattern are accepted.

• #​14776 3537876 Thanks @​ktym4a! - Fixes the behavior of passthroughImageService so it does not generate webp.

• Updated dependencies [9e9c528, 0f75f6b]:

  • @​astrojs/internal-helpers@​0.7.5
  • @​astrojs/markdown-remark@​6.3.9

v5.15.8

Compare Source

Patch Changes

• #​14772 00c579a Thanks @​matthewp! - Improves the security of Server Islands slots by encrypting them before transmission to the browser, matching the security model used for props. This improves the integrity of slot content and prevents injection attacks, even when component templates don't explicitly support slots.

  Slots continue to work as expected for normal usage—this change has no breaking changes for legitimate requests.

• #​14771 6f80081 Thanks @​matthewp! - Fix middleware pathname matching by normalizing URL-encoded paths

  Middleware now receives normalized pathname values, ensuring that encoded paths like /%61dmin are properly decoded to /admin before middleware checks. This prevents potential security issues where middleware checks might be bypassed through URL encoding.

v5.15.7

Compare Source

Patch Changes

• #​14765 03fb47c Thanks @​florian-lefebvre! - Fixes a case where process.env wouldn't be properly populated during the build

• #​14690 ae7197d Thanks @​fredriknorlin! - Fixes a bug where Astro's i18n fallback system with fallbackType: 'rewrite' would not generate fallback files for pages whose filename started with a locale key.

v5.15.6

Compare Source

Patch Changes

• #​14751 18c55e1 Thanks @​delucis! - Fixes hydration of client components when running the dev server and using a barrel file that re-exports both Astro and UI framework components.

• #​14750 35122c2 Thanks @​florian-lefebvre! - Updates the experimental Fonts API to log a warning if families with a conflicting cssVariable are provided

• #​14737 74c8852 Thanks @​Arecsu! - Fixes an error when using transition:persist with components that use declarative Shadow DOM. Astro now avoids re-attaching a shadow root if one already exists, preventing "Unable to re-attach to existing ShadowDOM" navigation errors.

• #​14750 35122c2 Thanks @​florian-lefebvre! - Updates the experimental Fonts API to allow for more granular configuration of remote font families

  A font family is defined by a combination of properties such as weights and styles (e.g. weights: [500, 600] and styles: ["normal", "bold"]), but you may want to download only certain combinations of these.

  For greater control over which font files are downloaded, you can specify the same font (ie. with the same cssVariable, name, and provider properties) multiple times with different combinations. Astro will merge the results and download only the required files. For example, it is possible to download normal 500 and 600 while downloading only italic 500:

  // astro.config.mjs
  import { defineConfig, fontProviders } from 'astro/config';
  
  export default defineConfig({
    experimental: {
      fonts: [
        {
          name: 'Roboto',
          cssVariable: '--roboto',
          provider: fontProviders.google(),
          weights: [500, 600],
          styles: ['normal'],
        },
        {
          name: 'Roboto',
          cssVariable: '--roboto',
          provider: fontProviders.google(),
          weights: [500],
          styles: ['italic'],
        },
      ],
    },
  });

---

• If you want to rebase/retry this PR, check this box