astro 5.16.5 → 6.0.0-alpha.1

package/dist/assets/build/generate.d.ts

@@ -1,4 +1,4 @@
-import type { BuildPipeline } from '../../core/build/pipeline.js';
+import type { BuildApp } from '../../core/build/app.js';
 import type { Logger } from '../../core/logger/core.js';
 import type { MapValue } from '../../type-utils.js';
 import type { AstroConfig } from '../../types/public/config.js';
@@ -17,7 +17,7 @@ type AssetEnv = {
     imageConfig: AstroConfig['image'];
     assetsFolder: AstroConfig['build']['assets'];
 };
-export declare function prepareAssetsGenerationEnv(pipeline: BuildPipeline, totalCount: number): Promise<AssetEnv>;
+export declare function prepareAssetsGenerationEnv(app: BuildApp, totalCount: number): Promise<AssetEnv>;
 export declare function generateImagesForPath(originalFilePath: string, transformsAndPath: MapValue<AssetsGlobalStaticImagesList>, env: AssetEnv): Promise<void>;
 export declare function getStaticImageList(): AssetsGlobalStaticImagesList;
 export {};

package/dist/assets/build/generate.js

@@ -9,10 +9,12 @@ import { isRemotePath, removeLeadingForwardSlash } from "../../core/path.js";
 import { getConfiguredImageService } from "../internal.js";
 import { isESMImportedImage } from "../utils/imageKind.js";
 import { loadRemoteImage, revalidateRemoteImage } from "./remote.js";
-async function prepareAssetsGenerationEnv(pipeline, totalCount) {
-  const { config, logger, settings } = pipeline;
+async function prepareAssetsGenerationEnv(app, totalCount) {
+  const settings = app.getSettings();
+  const logger = app.logger;
+  const manifest = app.getManifest();
   let useCache = true;
-  const assetsCacheDir = new URL("assets/", config.cacheDir);
+  const assetsCacheDir = new URL("assets/", app.manifest.cacheDir);
   const count = { total: totalCount, current: 1 };
   try {
     await fs.promises.mkdir(assetsCacheDir, { recursive: true });
@@ -26,11 +28,11 @@ async function prepareAssetsGenerationEnv(pipeline, totalCount) {
   const isServerOutput = settings.buildOutput === "server";
   let serverRoot, clientRoot;
   if (isServerOutput) {
-    serverRoot = config.build.server;
-    clientRoot = config.build.client;
+    serverRoot = manifest.buildServerDir;
+    clientRoot = manifest.buildClientDir;
   } else {
-    serverRoot = getOutDirWithinCwd(config.outDir);
-    clientRoot = config.outDir;
+    serverRoot = getOutDirWithinCwd(manifest.outDir);
+    clientRoot = manifest.outDir;
   }
   return {
     logger,
@@ -40,8 +42,8 @@ async function prepareAssetsGenerationEnv(pipeline, totalCount) {
     assetsCacheDir,
     serverRoot,
     clientRoot,
-    imageConfig: config.image,
-    assetsFolder: config.build.assets
+    imageConfig: settings.config.image,
+    assetsFolder: manifest.assetsDir
   };
 }
 function getFullImagePath(originalFilePath, env) {

package/dist/assets/build/remote.js

@@ -48,27 +48,17 @@ async function revalidateRemoteImage(src, revalidationData) {
     lastModified: res.headers.get("Last-Modified") ?? (res.ok ? void 0 : revalidationData.lastModified)
   };
 }
-function webToCachePolicyRequest({ url, method, headers: _headers }) {
-  let headers = {};
-  try {
-    headers = Object.fromEntries(_headers.entries());
-  } catch {
-  }
+function webToCachePolicyRequest({ url, method, headers }) {
   return {
     method,
     url,
-    headers
+    headers: Object.fromEntries(headers.entries())
   };
 }
-function webToCachePolicyResponse({ status, headers: _headers }) {
-  let headers = {};
-  try {
-    headers = Object.fromEntries(_headers.entries());
-  } catch {
-  }
+function webToCachePolicyResponse({ status, headers }) {
   return {
     status,
-    headers
+    headers: Object.fromEntries(headers.entries())
   };
 }
 export {

package/dist/assets/endpoint/config.js

@@ -28,11 +28,11 @@ function getImageEndpointData(settings, mode, cwd) {
     segments,
     params: [],
     component: resolveInjectedRoute(endpointEntrypoint, settings.config.root, cwd).component,
-    generate: () => "",
     pathname: settings.config.image.endpoint.route,
     prerender: false,
     fallbackRoutes: [],
-    origin: "internal"
+    origin: "internal",
+    distURL: []
   };
 }
 export {

package/dist/assets/endpoint/dev.js

@@ -1,16 +1,17 @@
 import { root } from "astro:config/server";
 import { readFile } from "node:fs/promises";
-import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { isParentDirectory } from "@astrojs/internal-helpers/path";
 import { handleImageRequest, loadRemoteImage } from "./shared.js";
-function replaceFileSystemReferences(src) {
-  return os.platform().includes("win32") ? src.replace(/^\/@fs\//, "") : src.replace(/^\/@fs/, "");
-}
 async function loadLocalImage(src, url) {
   if (src.startsWith("/@fs/")) {
-    src = replaceFileSystemReferences(src);
-    if (!isParentDirectory(fileURLToPath(root), src)) {
+    try {
+      const res = await fetch(new URL(src, url));
+      if (!res.ok) {
+        return void 0;
+      }
+      return Buffer.from(await res.arrayBuffer());
+    } catch {
       return void 0;
     }
   }

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

@@ -1,192 +1,104 @@
-import { z } from 'zod';
-export declare const weightSchema: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
-export declare const styleSchema: z.ZodEnum<["normal", "italic", "oblique"]>;
-export declare const displaySchema: z.ZodEnum<["auto", "block", "swap", "fallback", "optional"]>;
+import * as z from 'zod/v4';
+export declare const weightSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+export declare const styleSchema: z.ZodEnum<{
+    normal: "normal";
+    italic: "italic";
+    oblique: "oblique";
+}>;
+export declare const displaySchema: z.ZodEnum<{
+    optional: "optional";
+    auto: "auto";
+    block: "block";
+    swap: "swap";
+    fallback: "fallback";
+}>;
 export declare const localFontFamilySchema: z.ZodObject<{
     provider: z.ZodLiteral<"local">;
-    variants: z.ZodArray<z.ZodObject<{
-        src: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<URL, z.ZodTypeDef, URL>]>, z.ZodObject<{
-            url: z.ZodUnion<[z.ZodString, z.ZodType<URL, z.ZodTypeDef, URL>]>;
+    variants: z.ZodTuple<[z.ZodObject<{
+        src: z.ZodTuple<[z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodObject<{
+            url: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
+            tech: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>], z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodObject<{
+            url: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
+            tech: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        style: z.ZodOptional<z.ZodEnum<{
+            normal: "normal";
+            italic: "italic";
+            oblique: "oblique";
+        }>>;
+        display: z.ZodOptional<z.ZodEnum<{
+            optional: "optional";
+            auto: "auto";
+            block: "block";
+            swap: "swap";
+            fallback: "fallback";
+        }>>;
+        stretch: z.ZodOptional<z.ZodString>;
+        featureSettings: z.ZodOptional<z.ZodString>;
+        variationSettings: z.ZodOptional<z.ZodString>;
+        unicodeRange: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
+    }, z.core.$strict>], z.ZodObject<{
+        src: z.ZodTuple<[z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodObject<{
+            url: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
+            tech: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>], z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodObject<{
+            url: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
             tech: z.ZodOptional<z.ZodString>;
-        }, "strict", z.ZodTypeAny, {
-            url: string | URL;
-            tech?: string | undefined;
-        }, {
-            url: string | URL;
-            tech?: string | undefined;
-        }>]>, "atleastone">;
-        weight: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-        style: z.ZodOptional<z.ZodEnum<["normal", "italic", "oblique"]>>;
-        display: z.ZodOptional<z.ZodEnum<["auto", "block", "swap", "fallback", "optional"]>>;
+        }, z.core.$strict>]>>;
+        weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        style: z.ZodOptional<z.ZodEnum<{
+            normal: "normal";
+            italic: "italic";
+            oblique: "oblique";
+        }>>;
+        display: z.ZodOptional<z.ZodEnum<{
+            optional: "optional";
+            auto: "auto";
+            block: "block";
+            swap: "swap";
+            fallback: "fallback";
+        }>>;
         stretch: z.ZodOptional<z.ZodString>;
         featureSettings: z.ZodOptional<z.ZodString>;
         variationSettings: z.ZodOptional<z.ZodString>;
-        unicodeRange: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
-    }, "strict", z.ZodTypeAny, {
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }, {
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }>, "atleastone">;
-    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        unicodeRange: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
+    }, z.core.$strict>>;
+    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
     name: z.ZodString;
     cssVariable: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    provider: "local";
-    name: string;
-    cssVariable: string;
-    variants: [{
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }, ...{
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }[]];
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-}, {
-    provider: "local";
-    name: string;
-    cssVariable: string;
-    variants: [{
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }, ...{
-        src: [string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        }, ...(string | URL | {
-            url: string | URL;
-            tech?: string | undefined;
-        })[]];
-        weight?: string | number | undefined;
-        style?: "normal" | "italic" | "oblique" | undefined;
-        display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-        stretch?: string | undefined;
-        featureSettings?: string | undefined;
-        variationSettings?: string | undefined;
-        unicodeRange?: [string, ...string[]] | undefined;
-    }[]];
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-}>;
+}, z.core.$strict>;
 export declare const remoteFontFamilySchema: z.ZodObject<{
     provider: z.ZodObject<{
-        entrypoint: z.ZodUnion<[z.ZodString, z.ZodType<URL, z.ZodTypeDef, URL>]>;
+        entrypoint: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, "strict", z.ZodTypeAny, {
-        entrypoint: string | URL;
-        config?: Record<string, any> | undefined;
-    }, {
-        entrypoint: string | URL;
-        config?: Record<string, any> | undefined;
-    }>;
-    weights: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "atleastone">>;
-    styles: z.ZodOptional<z.ZodArray<z.ZodEnum<["normal", "italic", "oblique"]>, "atleastone">>;
-    subsets: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
-    display: z.ZodOptional<z.ZodEnum<["auto", "block", "swap", "fallback", "optional"]>>;
+    }, z.core.$strict>;
+    weights: z.ZodOptional<z.ZodTuple<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>], z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    styles: z.ZodOptional<z.ZodTuple<[z.ZodEnum<{
+        normal: "normal";
+        italic: "italic";
+        oblique: "oblique";
+    }>], z.ZodEnum<{
+        normal: "normal";
+        italic: "italic";
+        oblique: "oblique";
+    }>>>;
+    subsets: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
+    display: z.ZodOptional<z.ZodEnum<{
+        optional: "optional";
+        auto: "auto";
+        block: "block";
+        swap: "swap";
+        fallback: "fallback";
+    }>>;
     stretch: z.ZodOptional<z.ZodString>;
     featureSettings: z.ZodOptional<z.ZodString>;
     variationSettings: z.ZodOptional<z.ZodString>;
-    unicodeRange: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
-    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    unicodeRange: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
+    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
     name: z.ZodString;
     cssVariable: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    provider: {
-        entrypoint: string | URL;
-        config?: Record<string, any> | undefined;
-    };
-    name: string;
-    cssVariable: string;
-    weights?: [string | number, ...(string | number)[]] | undefined;
-    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
-    subsets?: [string, ...string[]] | undefined;
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-    display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-    stretch?: string | undefined;
-    featureSettings?: string | undefined;
-    variationSettings?: string | undefined;
-    unicodeRange?: [string, ...string[]] | undefined;
-}, {
-    provider: {
-        entrypoint: string | URL;
-        config?: Record<string, any> | undefined;
-    };
-    name: string;
-    cssVariable: string;
-    weights?: [string | number, ...(string | number)[]] | undefined;
-    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
-    subsets?: [string, ...string[]] | undefined;
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-    display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
-    stretch?: string | undefined;
-    featureSettings?: string | undefined;
-    variationSettings?: string | undefined;
-    unicodeRange?: [string, ...string[]] | undefined;
-}>;
+}, z.core.$strict>;

package/dist/assets/fonts/config.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod/v4";
 import { LOCAL_PROVIDER_NAME } from "./constants.js";
 const weightSchema = z.union([z.string(), z.number()]);
 const styleSchema = z.enum(["normal", "italic", "oblique"]);
@@ -10,7 +10,7 @@ const familyPropertiesSchema = z.object({
   stretch: z.string().optional(),
   featureSettings: z.string().optional(),
   variationSettings: z.string().optional(),
-  unicodeRange: z.array(z.string()).nonempty().optional()
+  unicodeRange: z.tuple([z.string()], z.string()).optional()
 });
 const fallbacksSchema = z.object({
   fallbacks: z.array(z.string()).optional(),
@@ -21,22 +21,20 @@ const requiredFamilyAttributesSchema = z.object({
   cssVariable: z.string()
 });
 const entrypointSchema = z.union([z.string(), z.instanceof(URL)]);
+const srcSchema = z.union([
+  entrypointSchema,
+  z.object({ url: entrypointSchema, tech: z.string().optional() }).strict()
+]);
+const variantSchema = z.object({
+  ...familyPropertiesSchema.shape,
+  src: z.tuple([srcSchema], srcSchema)
+  // TODO: find a way to support subsets (through fontkit?)
+}).strict();
 const localFontFamilySchema = z.object({
   ...requiredFamilyAttributesSchema.shape,
   ...fallbacksSchema.shape,
   provider: z.literal(LOCAL_PROVIDER_NAME),
-  variants: z.array(
-    z.object({
-      ...familyPropertiesSchema.shape,
-      src: z.array(
-        z.union([
-          entrypointSchema,
-          z.object({ url: entrypointSchema, tech: z.string().optional() }).strict()
-        ])
-      ).nonempty()
-      // TODO: find a way to support subsets (through fontkit?)
-    }).strict()
-  ).nonempty()
+  variants: z.tuple([variantSchema], variantSchema)
 }).strict();
 const remoteFontFamilySchema = z.object({
   ...requiredFamilyAttributesSchema.shape,
@@ -49,9 +47,9 @@ const remoteFontFamilySchema = z.object({
     entrypoint: entrypointSchema,
     config: z.record(z.string(), z.any()).optional()
   }).strict(),
-  weights: z.array(weightSchema).nonempty().optional(),
-  styles: z.array(styleSchema).nonempty().optional(),
-  subsets: z.array(z.string()).nonempty().optional()
+  weights: z.tuple([weightSchema], weightSchema).optional(),
+  styles: z.tuple([styleSchema], styleSchema).optional(),
+  subsets: z.tuple([z.string()], z.string()).optional()
 }).strict();
 export {
   displaySchema,

package/dist/assets/fonts/infra/dev-remote-font-provider-mod-resolver.d.ts

@@ -1,9 +1,9 @@
-import type { ViteDevServer } from 'vite';
+import type { RunnableDevEnvironment } from 'vite';
 import type { RemoteFontProviderModResolver } from '../definitions.js';
 export declare class DevServerRemoteFontProviderModResolver implements RemoteFontProviderModResolver {
     #private;
-    constructor({ server, }: {
-        server: ViteDevServer;
+    constructor({ environment, }: {
+        environment: RunnableDevEnvironment;
     });
     resolve(id: string): Promise<any>;
 }

package/dist/assets/fonts/infra/dev-remote-font-provider-mod-resolver.js

@@ -1,12 +1,12 @@
 class DevServerRemoteFontProviderModResolver {
-  #server;
+  #environment;
   constructor({
-    server
+    environment
   }) {
-    this.#server = server;
+    this.#environment = environment;
   }
   async resolve(id) {
-    return await this.#server.ssrLoadModule(id);
+    return this.#environment.runner.import(id);
   }
 }
 export {

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

@@ -1,6 +1,6 @@
 import type { Font } from '@capsizecss/unpack';
 import type * as unifont from 'unifont';
-import type { z } from 'zod';
+import type * as z from 'zod/v4';
 import type { displaySchema, styleSchema, weightSchema } from './config.js';
 import type { FONT_TYPES, GENERIC_FALLBACK_NAMES, LOCAL_PROVIDER_NAME } from './constants.js';
 import type { CollectedFontForMetrics } from './core/optimize-fallbacks.js';

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

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import colors from "piccolore";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../core/constants.js";
 import { getAlgorithm, shouldTrackCspHashes } from "../../core/csp/common.js";
 import { generateCspDigest } from "../../core/encryption.js";
 import { collectErrorMetadata } from "../../core/errors/dev/utils.js";
@@ -138,8 +139,8 @@ function fontsPlugin({ settings, sync, logger }) {
     fontFileDataMap = res.fontFileDataMap;
     internalConsumableMap = res.internalConsumableMap;
     consumableMap = res.consumableMap;
-    if (shouldTrackCspHashes(settings.config.experimental.csp)) {
-      const algorithm = getAlgorithm(settings.config.experimental.csp);
+    if (shouldTrackCspHashes(settings.config.security.csp)) {
+      const algorithm = getAlgorithm(settings.config.security.csp);
       for (const { css } of internalConsumableMap.values()) {
         settings.injectedCsp.styleHashes.push(await generateCspDigest(css, algorithm));
       }
@@ -172,7 +173,9 @@ function fontsPlugin({ settings, sync, logger }) {
       await initialize({
         // In dev, we cache fonts data in .astro so it can be easily inspected and cleared
         cacheDir: new URL(CACHE_DIR, settings.dotAstroDir),
-        modResolver: new DevServerRemoteFontProviderModResolver({ server }),
+        modResolver: new DevServerRemoteFontProviderModResolver({
+          environment: server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro]
+        }),
         cssRenderer: new MinifiableCssRenderer({ minify: false }),
         urlResolver: new DevUrlResolver({
           base: baseUrl,

package/dist/assets/services/sharp.js

@@ -45,25 +45,24 @@ const sharpService = {
       limitInputPixels: config.service.config.limitInputPixels
     });
     result.rotate();
-    const withoutEnlargement = Boolean(transform.fit);
-    if (transform.width && transform.height && transform.fit) {
-      const fit = fitMap[transform.fit] ?? "inside";
+    if (transform.width && transform.height) {
+      const fit = transform.fit ? fitMap[transform.fit] ?? "inside" : void 0;
       result.resize({
         width: Math.round(transform.width),
         height: Math.round(transform.height),
         fit,
         position: transform.position,
-        withoutEnlargement
+        withoutEnlargement: true
       });
     } else if (transform.height && !transform.width) {
       result.resize({
         height: Math.round(transform.height),
-        withoutEnlargement
+        withoutEnlargement: true
       });
     } else if (transform.width) {
       result.resize({
         width: Math.round(transform.width),
-        withoutEnlargement
+        withoutEnlargement: true
       });
     }
     if (transform.format) {

package/dist/assets/utils/index.d.ts

@@ -6,12 +6,6 @@
  */
 export { isESMImportedImage, isRemoteImage, resolveSrc } from './imageKind.js';
 export { imageMetadata } from './metadata.js';
-export { 
-/**
- * @deprecated
- */
-emitESMImage, emitImageMetadata, } from './node/emitAsset.js';
 export { getOrigQueryParams } from './queryParams.js';
 export { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern, } from './remotePattern.js';
 export { inferRemoteSize } from './remoteProbe.js';
-export { hashTransform, propsToFilename } from './transformToPath.js';

package/dist/assets/utils/index.js

@@ -1,9 +1,5 @@
 import { isESMImportedImage, isRemoteImage, resolveSrc } from "./imageKind.js";
 import { imageMetadata } from "./metadata.js";
-import {
-  emitESMImage,
-  emitImageMetadata
-} from "./node/emitAsset.js";
 import { getOrigQueryParams } from "./queryParams.js";
 import {
   isRemoteAllowed,
@@ -14,12 +10,8 @@ import {
   matchProtocol
 } from "./remotePattern.js";
 import { inferRemoteSize } from "./remoteProbe.js";
-import { hashTransform, propsToFilename } from "./transformToPath.js";
 export {
-  emitESMImage,
-  emitImageMetadata,
   getOrigQueryParams,
-  hashTransform,
   imageMetadata,
   inferRemoteSize,
   isESMImportedImage,
@@ -30,6 +22,5 @@ export {
   matchPattern,
   matchPort,
   matchProtocol,
-  propsToFilename,
   resolveSrc
 };

package/dist/assets/utils/{transformToPath.d.ts → node.d.ts}

@@ -1,4 +1,17 @@
-import type { ImageTransform } from '../types.js';
+import type * as vite from 'vite';
+import type { ImageMetadata, ImageTransform } from '../types.js';
+type FileEmitter = vite.Rollup.EmitFile;
+type ImageMetadataWithContents = ImageMetadata & {
+    contents?: Buffer;
+};
+/**
+ * Processes an image file and emits its metadata and optionally its contents. This function supports both build and development modes.
+ *
+ * @param {string | undefined} id - The identifier or path of the image file to process. If undefined, the function returns immediately.
+ * @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 emitImageMetadata(id: string | undefined, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;
 /**
  * Converts a file path and transformation properties of the transformation image service, into a formatted filename.
  *
@@ -31,3 +44,4 @@ export declare function propsToFilename(filePath: string, transform: ImageTransf
  * @return {string} A hashed string created from the specified properties of the `transform` object and the image service.
  */
 export declare function hashTransform(transform: ImageTransform, imageService: string, propertiesToHash: string[]): string;
+export {};