astro 5.6.2 → 5.7.1

package/dist/assets/fonts/utils.js

@@ -0,0 +1,215 @@
+import { createRequire } from "node:module";
+import { extname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { AstroError, AstroErrorData } from "../../core/errors/index.js";
+import { DEFAULT_FALLBACKS, FONT_TYPES, LOCAL_PROVIDER_NAME } from "./constants.js";
+import { resolveProvider } from "./providers/utils.js";
+function generateFontFace(family, font) {
+  return [
+    "@font-face {",
+    `  font-family: ${family};`,
+    `  src: ${renderFontSrc(font.src)};`,
+    `  font-display: ${font.display ?? "swap"};`,
+    font.unicodeRange && `  unicode-range: ${font.unicodeRange};`,
+    font.weight && `  font-weight: ${Array.isArray(font.weight) ? font.weight.join(" ") : font.weight};`,
+    font.style && `  font-style: ${font.style};`,
+    font.stretch && `  font-stretch: ${font.stretch};`,
+    font.featureSettings && `  font-feature-settings: ${font.featureSettings};`,
+    font.variationSettings && `  font-variation-settings: ${font.variationSettings};`,
+    `}`
+  ].filter(Boolean).join("\n");
+}
+function renderFontSrc(sources) {
+  return sources.map((src) => {
+    if ("url" in src) {
+      let rendered = `url("${src.url}")`;
+      for (const key of ["format", "tech"]) {
+        if (key in src) {
+          rendered += ` ${key}(${src[key]})`;
+        }
+      }
+      return rendered;
+    }
+    return `local("${src.name}")`;
+  }).join(", ");
+}
+function extractFontType(str) {
+  const extension = extname(str).slice(1);
+  if (!isFontType(extension)) {
+    throw new AstroError(
+      {
+        ...AstroErrorData.CannotExtractFontType,
+        message: AstroErrorData.CannotExtractFontType.message(str)
+      },
+      {
+        cause: `Unexpected extension, got "${extension}"`
+      }
+    );
+  }
+  return extension;
+}
+function isFontType(str) {
+  return FONT_TYPES.includes(str);
+}
+async function cache(storage, key, cb) {
+  const existing = await storage.getItemRaw(key);
+  if (existing) {
+    return existing;
+  }
+  const data = await cb();
+  await storage.setItemRaw(key, data);
+  return data;
+}
+function proxyURL({ value, hashString, collect }) {
+  const type = extractFontType(value);
+  const hash = `${hashString(value)}.${type}`;
+  const url = collect({ hash, type, value });
+  return url;
+}
+function isGenericFontFamily(str) {
+  return Object.keys(DEFAULT_FALLBACKS).includes(str);
+}
+async function generateFallbacksCSS({
+  family,
+  fallbacks: _fallbacks,
+  font: fontData,
+  metrics
+}) {
+  let fallbacks = [..._fallbacks];
+  if (fallbacks.length === 0) {
+    return null;
+  }
+  let css = "";
+  if (!fontData || !metrics) {
+    return { css, fallbacks };
+  }
+  const lastFallback = fallbacks[fallbacks.length - 1];
+  if (!isGenericFontFamily(lastFallback)) {
+    return { css, fallbacks };
+  }
+  const localFonts = DEFAULT_FALLBACKS[lastFallback];
+  if (localFonts.length === 0) {
+    return { css, fallbacks };
+  }
+  const foundMetrics = await metrics.getMetricsForFamily(family.name, fontData);
+  if (!foundMetrics) {
+    return { css, fallbacks };
+  }
+  const localFontsMappings = localFonts.map((font) => ({
+    font,
+    name: `"${family.nameWithHash} fallback: ${font}"`
+  }));
+  fallbacks = [.../* @__PURE__ */ new Set([...localFontsMappings.map((m) => m.name), ...fallbacks])];
+  for (const { font, name } of localFontsMappings) {
+    css += metrics.generateFontFace(foundMetrics, { font, name });
+  }
+  return { css, fallbacks };
+}
+function dedupe(arr) {
+  return [...new Set(arr)];
+}
+function resolveVariants({
+  variants,
+  root
+}) {
+  return variants.map((variant) => ({
+    ...variant,
+    weight: variant.weight.toString(),
+    src: variant.src.map((value) => {
+      const isValue = typeof value === "string" || value instanceof URL;
+      const url = (isValue ? value : value.url).toString();
+      const tech = isValue ? void 0 : value.tech;
+      return {
+        url: fileURLToPath(resolveEntrypoint(root, url)),
+        tech
+      };
+    })
+  }));
+}
+async function resolveFontFamily({
+  family,
+  generateNameWithHash,
+  root,
+  resolveMod
+}) {
+  const nameWithHash = generateNameWithHash(family);
+  if (family.provider === LOCAL_PROVIDER_NAME) {
+    return {
+      ...family,
+      nameWithHash,
+      variants: resolveVariants({ variants: family.variants, root }),
+      fallbacks: family.fallbacks ? dedupe(family.fallbacks) : void 0
+    };
+  }
+  return {
+    ...family,
+    nameWithHash,
+    provider: await resolveProvider({
+      root,
+      resolveMod,
+      provider: family.provider
+    }),
+    weights: family.weights ? dedupe(family.weights.map((weight) => weight.toString())) : void 0,
+    styles: family.styles ? dedupe(family.styles) : void 0,
+    subsets: family.subsets ? dedupe(family.subsets) : void 0,
+    fallbacks: family.fallbacks ? dedupe(family.fallbacks) : void 0,
+    unicodeRange: family.unicodeRange ? dedupe(family.unicodeRange) : void 0
+  };
+}
+function sortObjectByKey(unordered) {
+  const ordered = Object.keys(unordered).sort().reduce((obj, key) => {
+    obj[key] = unordered[key];
+    return obj;
+  }, {});
+  return ordered;
+}
+function familiesToUnifontProviders({
+  families,
+  hashString
+}) {
+  const hashes = /* @__PURE__ */ new Set();
+  const providers = [];
+  for (const { provider } of families) {
+    if (provider === LOCAL_PROVIDER_NAME) {
+      continue;
+    }
+    const unifontProvider = provider.provider(provider.config);
+    const hash = hashString(
+      JSON.stringify(
+        sortObjectByKey({
+          name: unifontProvider._name,
+          ...provider.config
+        })
+      )
+    );
+    if (hashes.has(hash)) {
+      continue;
+    }
+    unifontProvider._name += `-${hash}`;
+    provider.name = unifontProvider._name;
+    hashes.add(hash);
+    providers.push(unifontProvider);
+  }
+  return { families, providers };
+}
+function resolveEntrypoint(root, entrypoint) {
+  const require2 = createRequire(root);
+  try {
+    return pathToFileURL(require2.resolve(entrypoint));
+  } catch {
+    return new URL(entrypoint, root);
+  }
+}
+export {
+  cache,
+  extractFontType,
+  familiesToUnifontProviders,
+  generateFallbacksCSS,
+  generateFontFace,
+  isFontType,
+  isGenericFontFamily,
+  proxyURL,
+  resolveEntrypoint,
+  resolveFontFamily,
+  sortObjectByKey
+};

package/dist/assets/fonts/vite-plugin-fonts.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite';
+import type { Logger } from '../../core/logger/core.js';
+import type { AstroSettings } from '../../types/astro.js';
+interface Options {
+    settings: AstroSettings;
+    sync: boolean;
+    logger: Logger;
+}
+export declare function fontsPlugin({ settings, sync, logger }: Options): Plugin;
+export {};

package/dist/assets/fonts/vite-plugin-fonts.js

@@ -0,0 +1,212 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
+import { createStorage } from "unstorage";
+import fsLiteDriver from "unstorage/drivers/fs-lite";
+import xxhash from "xxhash-wasm";
+import { collectErrorMetadata } from "../../core/errors/dev/utils.js";
+import { AstroError, AstroErrorData, isAstroError } from "../../core/errors/index.js";
+import { formatErrorMessage } from "../../core/messages.js";
+import { getClientOutputDirectory } from "../../prerender/utils.js";
+import {
+  CACHE_DIR,
+  RESOLVED_VIRTUAL_MODULE_ID,
+  URL_PREFIX,
+  VIRTUAL_MODULE_ID
+} from "./constants.js";
+import { loadFonts } from "./load.js";
+import { generateFallbackFontFace, readMetrics } from "./metrics.js";
+import { cache, extractFontType, resolveFontFamily, sortObjectByKey } from "./utils.js";
+async function fetchFont(url) {
+  try {
+    if (isAbsolute(url)) {
+      return await readFile(url);
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Response was not successful, received status code ${response.status}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+  } catch (cause) {
+    throw new AstroError(
+      {
+        ...AstroErrorData.CannotFetchFontFile,
+        message: AstroErrorData.CannotFetchFontFile.message(url)
+      },
+      { cause }
+    );
+  }
+}
+function fontsPlugin({ settings, sync, logger }) {
+  if (!settings.config.experimental.fonts) {
+    return {
+      name: "astro:fonts:fallback",
+      config() {
+        return {
+          build: {
+            rollupOptions: {
+              external: [VIRTUAL_MODULE_ID]
+            }
+          }
+        };
+      }
+    };
+  }
+  const baseUrl = removeTrailingForwardSlash(settings.config.base) + URL_PREFIX;
+  let resolvedMap = null;
+  let hashToUrlMap = null;
+  let isBuild;
+  let storage = null;
+  const cleanup = () => {
+    resolvedMap = null;
+    hashToUrlMap = null;
+    storage = null;
+  };
+  async function initialize({ resolveMod, base }) {
+    const { h64ToString } = await xxhash();
+    storage = createStorage({
+      // Types are weirly exported
+      driver: fsLiteDriver({
+        base: fileURLToPath(base)
+      })
+    });
+    hashToUrlMap = /* @__PURE__ */ new Map();
+    resolvedMap = /* @__PURE__ */ new Map();
+    const families = [];
+    for (const family of settings.config.experimental.fonts) {
+      families.push(
+        await resolveFontFamily({
+          family,
+          root: settings.config.root,
+          resolveMod,
+          generateNameWithHash: (_family) => `${_family.name}-${h64ToString(JSON.stringify(sortObjectByKey(_family)))}`
+        })
+      );
+    }
+    await loadFonts({
+      base: baseUrl,
+      families,
+      storage,
+      hashToUrlMap,
+      resolvedMap,
+      hashString: h64ToString,
+      generateFallbackFontFace,
+      getMetricsForFamily: async (name, font) => {
+        return await readMetrics(name, await cache(storage, font.hash, () => fetchFont(font.url)));
+      },
+      log: (message) => logger.info("assets", message)
+    });
+  }
+  return {
+    name: "astro:fonts",
+    config(_, { command }) {
+      isBuild = command === "build";
+    },
+    async buildStart() {
+      if (isBuild) {
+        await initialize({
+          resolveMod: (id) => import(id),
+          base: new URL(CACHE_DIR, settings.config.cacheDir)
+        });
+      }
+    },
+    async configureServer(server) {
+      await initialize({
+        resolveMod: (id) => server.ssrLoadModule(id),
+        // In dev, we cache fonts data in .astro so it can be easily inspected and cleared
+        base: new URL(CACHE_DIR, settings.dotAstroDir)
+      });
+      const localPaths = [...hashToUrlMap.values()].filter((url) => isAbsolute(url));
+      server.watcher.on("change", (path) => {
+        if (localPaths.includes(path)) {
+          logger.info("assets", "Font file updated");
+          server.restart();
+        }
+      });
+      server.watcher.on("unlink", (path) => {
+        if (localPaths.includes(path)) {
+          logger.warn(
+            "assets",
+            `The font file ${JSON.stringify(path)} referenced in your config has been deleted. Restore the file or remove this font from your configuration if it is no longer needed.`
+          );
+        }
+      });
+      server.middlewares.use(URL_PREFIX, async (req, res, next) => {
+        if (!req.url) {
+          return next();
+        }
+        const hash = req.url.slice(1);
+        const url = hashToUrlMap?.get(hash);
+        if (!url) {
+          return next();
+        }
+        res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
+        res.setHeader("Pragma", "no-cache");
+        res.setHeader("Expires", 0);
+        try {
+          const data = await cache(storage, hash, () => fetchFont(url));
+          res.setHeader("Content-Length", data.length);
+          res.setHeader("Content-Type", `font/${extractFontType(hash)}`);
+          res.end(data);
+        } catch (err) {
+          logger.error("assets", "Cannot download font file");
+          if (isAstroError(err)) {
+            logger.error(
+              "SKIP_FORMAT",
+              formatErrorMessage(collectErrorMetadata(err), logger.level() === "debug")
+            );
+          }
+          res.statusCode = 500;
+          res.end();
+        }
+      });
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+        return {
+          code: `export const fontsData = new Map(${JSON.stringify(Array.from(resolvedMap?.entries() ?? []))})`
+        };
+      }
+    },
+    async buildEnd() {
+      if (sync || settings.config.experimental.fonts.length === 0) {
+        cleanup();
+        return;
+      }
+      try {
+        const dir = getClientOutputDirectory(settings);
+        const fontsDir = new URL("." + baseUrl, dir);
+        try {
+          mkdirSync(fontsDir, { recursive: true });
+        } catch (cause) {
+          throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
+        }
+        if (hashToUrlMap) {
+          logger.info("assets", "Copying fonts...");
+          await Promise.all(
+            Array.from(hashToUrlMap.entries()).map(async ([hash, url]) => {
+              const data = await cache(storage, hash, () => fetchFont(url));
+              try {
+                writeFileSync(new URL(hash, fontsDir), data);
+              } catch (cause) {
+                throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
+              }
+            })
+          );
+        }
+      } finally {
+        cleanup();
+      }
+    }
+  };
+}
+export {
+  fontsPlugin
+};

package/dist/assets/utils/node/emitAsset.d.ts

@@ -9,13 +9,15 @@ type ImageMetadataWithContents = ImageMetadata & {
  *
  * @param {string | undefined} id - The identifier or path of the image file to process. If undefined, the function returns immediately.
  * @param {boolean} _watchMode - **Deprecated**: Indicates if the method is operating in watch mode. This parameter will be removed or updated in the future.
- * @param {boolean} experimentalSvgEnabled - A flag to enable experimental handling of SVG files. Embeds SVG file data if set to true.
+ * @param {boolean} _experimentalSvgEnabled - **Deprecated**: A flag to enable experimental handling of SVG files. Embeds SVG file data if set to true.
  * @param {FileEmitter | undefined} [fileEmitter] - Function for emitting files during the build process. May throw in certain scenarios.
  * @return {Promise<ImageMetadataWithContents | undefined>} Resolves to metadata with optional image contents or `undefined` if processing fails.
  */
 export declare function emitESMImage(id: string | undefined, 
 /** @deprecated */
-_watchMode: boolean, experimentalSvgEnabled: boolean, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;
+_watchMode: boolean, 
+/** @deprecated */
+_experimentalSvgEnabled: boolean, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;
 /**
  * Processes an image file and emits its metadata and optionally its contents. This function supports both build and development modes.
  *

package/dist/assets/utils/node/emitAsset.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { prependForwardSlash, slash } from "../../../core/path.js";
 import { imageMetadata } from "../metadata.js";
-async function emitESMImage(id, _watchMode, experimentalSvgEnabled, fileEmitter) {
+async function emitESMImage(id, _watchMode, _experimentalSvgEnabled, fileEmitter) {
   if (!id) {
     return void 0;
   }

package/dist/assets/utils/vendor/image-size/types/index.d.ts

@@ -1,3 +1,3 @@
-export declare const typeHandlers: Map<"svg" | "jpg" | "png" | "tiff" | "webp" | "gif" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga", import("./interface.js").IImage>;
-export declare const types: ("svg" | "jpg" | "png" | "tiff" | "webp" | "gif" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga")[];
+export declare const typeHandlers: Map<"jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga", import("./interface.js").IImage>;
+export declare const types: ("jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga")[];
 export type imageType = typeof types[number];

package/dist/assets/vite-plugin-assets.d.ts

@@ -1,7 +1,12 @@
 import type * as fsMod from 'node:fs';
 import type * as vite from 'vite';
+import type { Logger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
-export default function assets({ fs, settings, }: {
-    fs: typeof fsMod;
+interface Options {
     settings: AstroSettings;
-}): vite.Plugin[];
+    sync: boolean;
+    logger: Logger;
+    fs: typeof fsMod;
+}
+export default function assets({ fs, settings, sync, logger }: Options): vite.Plugin[];
+export {};

package/dist/assets/vite-plugin-assets.js

@@ -10,6 +10,7 @@ import {
 } from "../core/path.js";
 import { normalizePath } from "../core/viteUtils.js";
 import { VALID_INPUT_FORMATS, VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
+import { fontsPlugin } from "./fonts/vite-plugin-fonts.js";
 import { getAssetsPrefix } from "./utils/getAssetsPrefix.js";
 import { isESMImportedImage } from "./utils/imageKind.js";
 import { emitESMImage } from "./utils/node/emitAsset.js";
@@ -63,10 +64,7 @@ const addStaticImageFactory = (settings) => {
     }
   };
 };
-function assets({
-  fs,
-  settings
-}) {
+function assets({ fs, settings, sync, logger }) {
   let resolvedConfig;
   let shouldEmitFile = false;
   let isBuild = false;
@@ -97,6 +95,7 @@ function assets({
 							import { getImage as getImageInternal } from "astro/assets";
 							export { default as Image } from "astro/components/${imageComponentPrefix}Image.astro";
 							export { default as Picture } from "astro/components/${imageComponentPrefix}Picture.astro";
+							export { default as Font } from "astro/components/Font.astro";
 							export { inferRemoteSize } from "astro/assets/utils/inferRemoteSize.js";
 
 							export const imageConfig = ${JSON.stringify({ ...settings.config.image, experimentalResponsiveImages: settings.config.experimental.responsiveImages })};
@@ -173,7 +172,7 @@ function assets({
           const imageMetadata = await emitESMImage(
             id,
             this.meta.watchMode,
-            !!settings.config.experimental.svg,
+            id.endsWith(".svg"),
             emitFile
           );
           if (!imageMetadata) {
@@ -182,7 +181,7 @@ function assets({
               message: AstroErrorData.ImageNotFound.message(id)
             });
           }
-          if (settings.config.experimental.svg && /\.svg$/.test(id)) {
+          if (id.endsWith(".svg")) {
             const contents = await fs.promises.readFile(imageMetadata.fsPath, { encoding: "utf8" });
             return { code: makeSvgComponent(imageMetadata, contents) };
           }
@@ -201,7 +200,8 @@ function assets({
           }
         }
       }
-    }
+    },
+    fontsPlugin({ settings, sync, logger })
   ];
 }
 export {

package/dist/config/entrypoint.d.ts

@@ -4,6 +4,8 @@ export { defineConfig, getViteConfig } from './index.js';
 export { envField } from '../env/config.js';
 export { mergeConfig } from '../core/config/merge.js';
 export { validateConfig } from '../core/config/validate.js';
+export { fontProviders, defineAstroFontProvider } from '../assets/fonts/providers/index.js';
+export type { AstroFontProvider } from '../assets/fonts/types.js';
 /**
  * Return the configuration needed to use the Sharp-based image service
  */

package/dist/config/entrypoint.js

@@ -2,6 +2,7 @@ import { defineConfig, getViteConfig } from "./index.js";
 import { envField } from "../env/config.js";
 import { mergeConfig } from "../core/config/merge.js";
 import { validateConfig } from "../core/config/validate.js";
+import { fontProviders, defineAstroFontProvider } from "../assets/fonts/providers/index.js";
 function sharpImageService(config = {}) {
   return {
     entrypoint: "astro/assets/services/sharp",
@@ -15,8 +16,10 @@ function passthroughImageService() {
   };
 }
 export {
+  defineAstroFontProvider,
   defineConfig,
   envField,
+  fontProviders,
   getViteConfig,
   mergeConfig,
   passthroughImageService,

package/dist/config/index.d.ts

@@ -1,10 +1,11 @@
 import type { UserConfig as ViteUserConfig, UserConfigFn as ViteUserConfigFn } from 'vite';
+import type { FontFamily } from '../assets/fonts/types.js';
 import type { AstroInlineConfig, AstroUserConfig, Locales, SessionDriverName } from '../types/public/config.js';
 /**
  * See the full Astro Configuration API Documentation
  * https://astro.build/config
  */
-export declare function defineConfig<const TLocales extends Locales = never, const TDriver extends SessionDriverName = never>(config: AstroUserConfig<TLocales, TDriver>): AstroUserConfig<TLocales, TDriver>;
+export declare function defineConfig<const TLocales extends Locales = never, const TDriver extends SessionDriverName = never, const TFontFamilies extends FontFamily[] = never>(config: AstroUserConfig<TLocales, TDriver, TFontFamilies>): AstroUserConfig<TLocales, TDriver, TFontFamilies>;
 /**
  * Use Astro to generate a fully resolved Vite config
  */

package/dist/content/content-layer.js

@@ -153,7 +153,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.6.2") {
+    if (previousAstroVersion && previousAstroVersion !== "5.7.1") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -161,8 +161,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.6.2") {
-      await this.#store.metaStore().set("astro-version", "5.6.2");
+    if ("5.7.1") {
+      await this.#store.metaStore().set("astro-version", "5.7.1");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);
@@ -202,7 +202,8 @@ ${contentConfig.error.message}`);
             },
             collectionWithResolvedSchema,
             false,
-            !!this.#settings.config.experimental.svg
+            // FUTURE: Remove in this in v6
+            id.endsWith(".svg")
           );
           return parsedData;
         };

package/dist/content/runtime-assets.js

@@ -7,6 +7,7 @@ function createImage(pluginContext, shouldEmitFile, entryFilePath, experimentalS
       const metadata = await emitESMImage(
         resolvedFilePath,
         pluginContext.meta.watchMode,
+        // FUTURE: Remove in this in v6
         experimentalSvgEnabled,
         shouldEmitFile ? pluginContext.emitFile : void 0
       );

package/dist/content/vite-plugin-content-imports.js

@@ -171,7 +171,8 @@ async function getContentEntryModule(params) {
     { id, collection, _internal, unvalidatedData },
     collectionConfig,
     params.shouldEmitFile,
-    !!params.config.experimental.svg,
+    // FUTURE: Remove in this in v6
+    id.endsWith(".svg"),
     pluginContext
   ) : unvalidatedData;
   const contentEntryModule = {
@@ -197,7 +198,8 @@ async function getDataEntryModule(params) {
     { id, collection, _internal, unvalidatedData },
     collectionConfig,
     params.shouldEmitFile,
-    !!params.config.experimental.svg,
+    // FUTURE: Remove in this in v6
+    id.endsWith(".svg"),
     pluginContext
   ) : unvalidatedData;
   const dataEntryModule = {

package/dist/core/build/generate.js

@@ -18,7 +18,7 @@ import {
 } from "../../core/path.js";
 import { toFallbackType, toRoutingStrategy } from "../../i18n/utils.js";
 import { runHookBuildGenerated } from "../../integrations/hooks.js";
-import { getOutputDirectory } from "../../prerender/utils.js";
+import { getServerOutputDirectory } from "../../prerender/utils.js";
 import { NoPrerenderedRoutesWithDomains } from "../errors/errors-data.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { NOOP_MIDDLEWARE_FN } from "../middleware/noop-middleware.js";
@@ -41,7 +41,7 @@ async function generatePages(options, internals) {
   if (ssr) {
     manifest = await BuildPipeline.retrieveManifest(options.settings, internals);
   } else {
-    const baseDirectory = getOutputDirectory(options.settings);
+    const baseDirectory = getServerOutputDirectory(options.settings);
     const renderersEntryUrl = new URL("renderers.mjs", baseDirectory);
     const renderers = await import(renderersEntryUrl.toString());
     const middleware = internals.middlewareEntryPoint ? await import(internals.middlewareEntryPoint.toString()).then((mod) => mod.onRequest) : NOOP_MIDDLEWARE_FN;