astro 6.1.10 → 6.2.1

package/client.d.ts

@@ -60,6 +60,7 @@ declare module 'astro:assets' {
 		import('astro:assets').CssVariable,
 		Array<import('astro:assets').FontData>
 	>;
+	export const experimental_getFontFileURL: typeof import('./dist/assets/fonts/runtime.js').experimental_getFontFileURL;
 
 	type ImgAttributes = import('./dist/type-utils.js').WithRequired<
 		Omit<import('./types').HTMLAttributes<'img'>, 'src' | 'width' | 'height'>,

package/dist/actions/runtime/types.d.ts

@@ -49,7 +49,7 @@ export interface ActionsLocals {
         actionName: string;
     };
 }
-export type ActionAPIContext = Pick<APIContext, 'request' | 'url' | 'isPrerendered' | 'locals' | 'clientAddress' | 'cookies' | 'currentLocale' | 'generator' | 'routePattern' | 'site' | 'params' | 'preferredLocale' | 'preferredLocaleList' | 'originPathname' | 'session' | 'cache' | 'csp'>;
+export type ActionAPIContext = Pick<APIContext, 'request' | 'url' | 'isPrerendered' | 'locals' | 'clientAddress' | 'cookies' | 'currentLocale' | 'generator' | 'routePattern' | 'site' | 'params' | 'preferredLocale' | 'preferredLocaleList' | 'originPathname' | 'session' | 'cache' | 'csp' | 'logger'>;
 export type MaybePromise<T> = T | Promise<T>;
 /**
  * Used to preserve the input schema type in the error object.

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

@@ -4,6 +4,8 @@ export declare const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
 export declare const RUNTIME_VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/runtime";
 export declare const RESOLVED_RUNTIME_VIRTUAL_MODULE_ID: string;
+export declare const RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/runtime/font-file-url-resolver";
+export declare const RESOLVED_RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID: string;
 export declare const ASSETS_DIR = "fonts";
 export declare const CACHE_DIR = "./fonts/";
 export declare const FONT_TYPES: readonly ["woff2", "woff", "otf", "ttf", "eot"];

package/dist/assets/fonts/constants.js

@@ -11,6 +11,8 @@ const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
 const RUNTIME_VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/runtime";
 const RESOLVED_RUNTIME_VIRTUAL_MODULE_ID = "\0" + RUNTIME_VIRTUAL_MODULE_ID;
+const RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/runtime/font-file-url-resolver";
+const RESOLVED_RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID = "\0" + RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID;
 const ASSETS_DIR = "fonts";
 const CACHE_DIR = "./fonts/";
 const FONT_TYPES = ["woff2", "woff", "otf", "ttf", "eot"];
@@ -45,8 +47,10 @@ export {
   FONT_FORMATS,
   FONT_TYPES,
   GENERIC_FALLBACK_NAMES,
+  RESOLVED_RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID,
   RESOLVED_RUNTIME_VIRTUAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
+  RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID,
   RUNTIME_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 };

package/dist/assets/fonts/core/create-get-font-file-url.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeFontFileUrlResolver } from '../definitions.js';
+export declare function createGetFontFileURL(runtimeFontFileUrlResolver: RuntimeFontFileUrlResolver): (url: string, requestUrl?: URL) => string;

package/dist/assets/fonts/core/create-get-font-file-url.js

@@ -0,0 +1,23 @@
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+function createGetFontFileURL(runtimeFontFileUrlResolver) {
+  return function getFontFileURL(url, requestUrl) {
+    try {
+      const result = runtimeFontFileUrlResolver.resolve(url, requestUrl);
+      if (result === null) {
+        throw new Error("Not found");
+      }
+      return result;
+    } catch (cause) {
+      throw new AstroError(
+        {
+          ...AstroErrorData.FontFileUrlNotFound,
+          message: AstroErrorData.FontFileUrlNotFound.message(url)
+        },
+        { cause }
+      );
+    }
+  };
+}
+export {
+  createGetFontFileURL
+};

package/dist/assets/fonts/core/font-file-middleware.d.ts

@@ -0,0 +1,21 @@
+import type { AstroLogger } from '../../../core/logger/core.js';
+import type { FontFetcher, FontTypeExtractor } from '../definitions.js';
+import type { FontFileById } from '../types.js';
+import type { ServerResponse } from 'node:http';
+interface MinimalResponse {
+    setHeader: (name: string, value: string) => void;
+    end: (buffer?: Buffer) => void;
+    setStatusCode: (statusCode: number) => void;
+}
+interface Options {
+    url: string | undefined;
+    response: MinimalResponse;
+    next: () => void;
+    fontFetcher: FontFetcher | null;
+    fontTypeExtractor: FontTypeExtractor | null;
+    logger: AstroLogger;
+    fontFileById: FontFileById | null;
+}
+export declare function resToMinimalResponse(res: ServerResponse): MinimalResponse;
+export declare function fontFileMiddleware({ url: _url, response, next, fontFetcher, fontTypeExtractor, logger, fontFileById, }: Options): Promise<void>;
+export {};

package/dist/assets/fonts/core/font-file-middleware.js

@@ -0,0 +1,59 @@
+import { isAstroError } from "../../../core/errors/errors.js";
+import { formatErrorMessage } from "../../../core/messages/runtime.js";
+import { collectErrorMetadata } from "../../../core/errors/dev/utils.js";
+function resToMinimalResponse(res) {
+  return {
+    setHeader: (...args) => res.setHeader(...args),
+    end: (...args) => res.end(...args),
+    setStatusCode: (statusCode) => {
+      res.statusCode = statusCode;
+    }
+  };
+}
+async function fontFileMiddleware({
+  url: _url,
+  response,
+  next,
+  fontFetcher,
+  fontTypeExtractor,
+  logger,
+  fontFileById
+}) {
+  if (!fontFetcher || !fontTypeExtractor || !fontFileById) {
+    logger.debug("assets", "Fonts dependencies should be initialized by now, skipping middleware.");
+    return next();
+  }
+  if (!_url) {
+    return next();
+  }
+  const url = new URL(_url, "http://localhost");
+  const fontId = url.pathname.slice(1);
+  const fontData = fontFileById.get(fontId);
+  if (!fontData) {
+    return next();
+  }
+  response.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
+  response.setHeader("Pragma", "no-cache");
+  response.setHeader("Expires", "0");
+  try {
+    const buffer = await fontFetcher.fetch({ id: fontId, ...fontData });
+    response.setHeader("Content-Length", buffer.byteLength.toString());
+    response.setHeader("Content-Type", `font/${fontTypeExtractor.extract(fontId)}`);
+    response.setStatusCode(200);
+    response.end(buffer);
+  } catch (err) {
+    logger.error("assets", "Cannot download font file");
+    if (isAstroError(err)) {
+      logger.error(
+        "SKIP_FORMAT",
+        formatErrorMessage(collectErrorMetadata(err), logger.level() === "debug")
+      );
+    }
+    response.setStatusCode(500);
+    response.end();
+  }
+}
+export {
+  fontFileMiddleware,
+  resToMinimalResponse
+};

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

@@ -8,6 +8,7 @@ export interface Hasher {
 export interface UrlResolver {
     resolve: (id: string) => string;
     readonly cspResources: Array<string>;
+    readonly urls: Array<string>;
 }
 export interface FontFileContentResolver {
     resolve: (url: string) => string;
@@ -70,3 +71,15 @@ export interface FontResolver {
         provider: FontProvider;
     }) => Promise<string[] | undefined>;
 }
+export interface RuntimeFontFileUrlResolver {
+    /**
+     * @param url
+     * URL obtained from `fontData` and provided by the user. Can look like
+     * `/_astro/fonts/<hash>.<ext>` or be a full URL when using assetsPrefix.
+     *
+     * @param requestUrl
+     * The current request URL. It can be used to construct a full URL to the
+     * font file, for example in SSR.
+     */
+    resolve: (url: string, requestUrl: URL | undefined) => string | null;
+}

package/dist/assets/fonts/infra/build-url-resolver.d.ts

@@ -9,4 +9,5 @@ export declare class BuildUrlResolver implements UrlResolver {
     });
     resolve(id: string): string;
     get cspResources(): Array<string>;
+    get urls(): Array<string>;
 }

package/dist/assets/fonts/infra/build-url-resolver.js

@@ -3,6 +3,7 @@ import { getAssetsPrefix } from "../../utils/getAssetsPrefix.js";
 import { createPlaceholderURL, stringifyPlaceholderURL } from "../../utils/url.js";
 class BuildUrlResolver {
   #resources = /* @__PURE__ */ new Set();
+  #urls = /* @__PURE__ */ new Set();
   #base;
   #assetsPrefix;
   #searchParams;
@@ -29,11 +30,16 @@ class BuildUrlResolver {
     this.#searchParams.forEach((value, key) => {
       url.searchParams.set(key, value);
     });
-    return stringifyPlaceholderURL(url);
+    const result = stringifyPlaceholderURL(url);
+    this.#urls.add(result);
+    return result;
   }
   get cspResources() {
     return Array.from(this.#resources);
   }
+  get urls() {
+    return Array.from(this.#urls);
+  }
 }
 export {
   BuildUrlResolver

package/dist/assets/fonts/infra/dev-url-resolver.d.ts

@@ -7,4 +7,5 @@ export declare class DevUrlResolver implements UrlResolver {
     });
     resolve(id: string): string;
     get cspResources(): Array<string>;
+    get urls(): Array<string>;
 }

package/dist/assets/fonts/infra/dev-url-resolver.js

@@ -1,6 +1,7 @@
 import { joinPaths, prependForwardSlash } from "../../../core/path.js";
 import { createPlaceholderURL, stringifyPlaceholderURL } from "../../utils/url.js";
 class DevUrlResolver {
+  #urls = /* @__PURE__ */ new Set();
   #resolved = false;
   #base;
   #searchParams;
@@ -18,11 +19,16 @@ class DevUrlResolver {
     this.#searchParams.forEach((value, key) => {
       url.searchParams.set(key, value);
     });
-    return stringifyPlaceholderURL(url);
+    const result = stringifyPlaceholderURL(url);
+    this.#urls.add(result);
+    return result;
   }
   get cspResources() {
     return this.#resolved ? ["'self'"] : [];
   }
+  get urls() {
+    return Array.from(this.#urls);
+  }
 }
 export {
   DevUrlResolver

package/dist/assets/fonts/infra/remote-runtime-font-file-url-resolver.d.ts

@@ -0,0 +1,19 @@
+import type { AddressInfo } from 'node:net';
+import type { RuntimeFontFileUrlResolver } from '../definitions.js';
+/**
+ * In development, font files are served through a Vite middleware.
+ * During prerendering, a temporary Node HTTP server is started to
+ * serve font files.
+ *
+ * We send request to the provided server address. `requestUrl` on
+ * `fetch` is not implemented because we have the information from
+ * within the Vite plugin already.
+ */
+export declare class RemoteRuntimeFontFileUrlResolver implements RuntimeFontFileUrlResolver {
+    #private;
+    constructor({ urls, address, }: {
+        urls: Set<string>;
+        address: AddressInfo | null;
+    });
+    resolve(url: string): string | null;
+}

package/dist/assets/fonts/infra/remote-runtime-font-file-url-resolver.js

@@ -0,0 +1,27 @@
+class RemoteRuntimeFontFileUrlResolver {
+  #urls;
+  #address;
+  constructor({
+    urls,
+    address
+  }) {
+    this.#urls = urls;
+    this.#address = address;
+  }
+  resolve(url) {
+    if (!this.#urls.has(url)) {
+      return null;
+    }
+    if (!this.#address) {
+      throw new Error("Server address unavailable, this should not happen. Open an issue.");
+    }
+    if (!url.startsWith("/")) {
+      url = new URL(url).pathname;
+    }
+    const host = this.#address.family === "IPv6" ? `[${this.#address.address}]` : this.#address.address;
+    return `http://${host}:${this.#address.port}${url}`;
+  }
+}
+export {
+  RemoteRuntimeFontFileUrlResolver
+};

package/dist/assets/fonts/infra/ssr-runtime-font-file-url-resolver.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeFontFileUrlResolver } from '../definitions.js';
+/**
+ * During SSR, we don't know ahead of time where the server is located.
+ * We rely on `requestUrl` (provided by the user) to construct the URL.
+ */
+export declare class SsrRuntimeFontFileUrlResolver implements RuntimeFontFileUrlResolver {
+    #private;
+    constructor({ urls, }: {
+        urls: Set<string>;
+    });
+    resolve(url: string, requestUrl: URL | undefined): string | null;
+}

package/dist/assets/fonts/infra/ssr-runtime-font-file-url-resolver.js

@@ -0,0 +1,25 @@
+import { MissingGetFontFileRequestUrl } from "../../../core/errors/errors-data.js";
+import { AstroError } from "../../../core/errors/errors.js";
+class SsrRuntimeFontFileUrlResolver {
+  #urls;
+  constructor({
+    urls
+  }) {
+    this.#urls = urls;
+  }
+  resolve(url, requestUrl) {
+    if (!this.#urls.has(url)) {
+      return null;
+    }
+    if (!url.startsWith("/")) {
+      return url;
+    }
+    if (!requestUrl) {
+      throw new AstroError(MissingGetFontFileRequestUrl);
+    }
+    return `${requestUrl.origin}${url}`;
+  }
+}
+export {
+  SsrRuntimeFontFileUrlResolver
+};

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

@@ -1 +1,2 @@
 export declare const fontData: import("./types.js").FontDataByCssVariable;
+export declare const experimental_getFontFileURL: (url: string, requestUrl?: URL) => string;

package/dist/assets/fonts/runtime.js

@@ -1,5 +1,9 @@
 import { fontDataByCssVariable } from "virtual:astro:assets/fonts/internal";
+import { runtimeFontFileUrlResolver } from "virtual:astro:assets/fonts/runtime/font-file-url-resolver";
+import { createGetFontFileURL } from "./core/create-get-font-file-url.js";
 const fontData = fontDataByCssVariable;
+const experimental_getFontFileURL = createGetFontFileURL(runtimeFontFileUrlResolver);
 export {
+  experimental_getFontFileURL,
   fontData
 };

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

@@ -1,20 +1,22 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
+import { createServer } from "node:http";
 import { isAbsolute } from "node:path";
 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";
-import { AstroError, AstroErrorData, isAstroError } from "../../core/errors/index.js";
-import { formatErrorMessage } from "../../core/messages/runtime.js";
+import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 import { appendForwardSlash, joinPaths, prependForwardSlash } from "../../core/path.js";
 import { getClientOutputDirectory } from "../../prerender/utils.js";
 import {
   ASSETS_DIR,
   CACHE_DIR,
   DEFAULTS,
+  RESOLVED_RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID,
   RESOLVED_RUNTIME_VIRTUAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
+  RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID,
   RUNTIME_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 } from "./constants.js";
@@ -40,6 +42,7 @@ import { RealSystemFallbacksProvider } from "./infra/system-fallbacks-provider.j
 import { UnifontFontResolver } from "./infra/unifont-font-resolver.js";
 import { UnstorageFsStorage } from "./infra/unstorage-fs-storage.js";
 import { XxhashHasher } from "./infra/xxhash-hasher.js";
+import { fontFileMiddleware, resToMinimalResponse } from "./core/font-file-middleware.js";
 function fontsPlugin({ settings, sync, logger }) {
   const assetsDir = prependForwardSlash(
     appendForwardSlash(joinPaths(settings.config.build.assets, ASSETS_DIR))
@@ -48,26 +51,27 @@ function fontsPlugin({ settings, sync, logger }) {
   let fontFileById = null;
   let componentDataByCssVariable = null;
   let fontDataByCssVariable = null;
-  let isBuild;
   let fontFetcher = null;
   let fontTypeExtractor = null;
   let built = false;
-  const cleanup = () => {
+  let serverAddress = null;
+  let urls = null;
+  function cleanup() {
     componentDataByCssVariable = null;
     fontDataByCssVariable = null;
     fontFileById = null;
     fontFetcher = null;
-  };
+    serverAddress = null;
+    urls = null;
+  }
   return {
     name: "astro:fonts",
-    config(_, { command }) {
-      isBuild = command === "build";
-    },
     async buildStart() {
       if (sync) {
         return;
       }
       const { root } = settings.config;
+      const isBuild = this.environment.config.command === "build";
       const hasher = await XxhashHasher.create();
       const storage = new UnstorageFsStorage({
         // In dev, we cache fonts data in .astro so it can be easily inspected and cleared
@@ -160,8 +164,39 @@ function fontsPlugin({ settings, sync, logger }) {
           settings.injectedCsp.fontResources.add(resource);
         }
       }
+      urls = urlResolver.urls;
+      if (this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender && fontFileById.size > 0) {
+        settings.fontsHttpServer = await new Promise((r) => {
+          const server = createServer((req, res) => {
+            const next = () => {
+              if (!res.writableEnded) {
+                res.writeHead(404);
+                res.end();
+              }
+            };
+            if (req.url?.startsWith(baseUrl)) {
+              return fontFileMiddleware({
+                url: req.url.slice(baseUrl.length - 1),
+                response: resToMinimalResponse(res),
+                next,
+                fontFetcher,
+                fontFileById,
+                fontTypeExtractor,
+                logger
+              });
+            }
+            return next();
+          }).listen(() => {
+            r(server);
+          });
+        });
+        serverAddress = settings.fontsHttpServer.address();
+      }
     },
     async configureServer(server) {
+      server.httpServer?.on("listening", () => {
+        serverAddress = server.httpServer?.address();
+      });
       server.watcher.on("change", (path) => {
         if (!fontFileById) {
           return;
@@ -184,47 +219,24 @@ function fontsPlugin({ settings, sync, logger }) {
           );
         }
       });
-      server.middlewares.use(assetsDir, async (req, res, next) => {
-        if (!fontFetcher || !fontTypeExtractor) {
-          logger.debug(
-            "assets",
-            "Fonts dependencies should be initialized by now, skipping dev middleware."
-          );
-          return next();
-        }
-        if (!req.url) {
-          return next();
-        }
-        const url = new URL(req.url, "http://localhost");
-        const fontId = url.pathname.slice(1);
-        const fontData = fontFileById?.get(fontId);
-        if (!fontData) {
-          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 buffer = await fontFetcher.fetch({ id: fontId, ...fontData });
-          res.setHeader("Content-Length", buffer.length);
-          res.setHeader("Content-Type", `font/${fontTypeExtractor.extract(fontId)}`);
-          res.end(buffer);
-        } 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();
-        }
-      });
+      server.middlewares.use(
+        assetsDir,
+        (req, res, next) => fontFileMiddleware({
+          url: req.url,
+          response: resToMinimalResponse(res),
+          next,
+          fontFetcher,
+          fontFileById,
+          fontTypeExtractor,
+          logger
+        })
+      );
     },
     resolveId: {
       filter: {
-        id: new RegExp(`^(${VIRTUAL_MODULE_ID}|${RUNTIME_VIRTUAL_MODULE_ID})$`)
+        id: new RegExp(
+          `^(${VIRTUAL_MODULE_ID}|${RUNTIME_VIRTUAL_MODULE_ID}|${RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID})$`
+        )
       },
       handler(id) {
         if (id === VIRTUAL_MODULE_ID) {
@@ -233,11 +245,16 @@ function fontsPlugin({ settings, sync, logger }) {
         if (id === RUNTIME_VIRTUAL_MODULE_ID) {
           return RESOLVED_RUNTIME_VIRTUAL_MODULE_ID;
         }
+        if (id === RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID) {
+          return RESOLVED_RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID;
+        }
       }
     },
     load: {
       filter: {
-        id: new RegExp(`^(${RESOLVED_VIRTUAL_MODULE_ID}|${RESOLVED_RUNTIME_VIRTUAL_MODULE_ID})$`)
+        id: new RegExp(
+          `^(${RESOLVED_VIRTUAL_MODULE_ID}|${RESOLVED_RUNTIME_VIRTUAL_MODULE_ID}|${RESOLVED_RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID})$`
+        )
       },
       async handler(id) {
         if (id === RESOLVED_VIRTUAL_MODULE_ID) {
@@ -253,13 +270,35 @@ function fontsPlugin({ settings, sync, logger }) {
             code: `export * from 'astro/assets/fonts/runtime.js';`
           };
         }
+        if (id === RESOLVED_RUNTIME_FONT_FILE_URL_RESOLVER_VIRTUAL_MODULE_ID) {
+          const isPrerender = this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+          if (this.environment.config.command === "build" && !isPrerender) {
+            return {
+              code: `
+								import { SsrRuntimeFontFileUrlResolver } from ${JSON.stringify(new URL("./infra/ssr-runtime-font-file-url-resolver.js", import.meta.url))};
+								export const runtimeFontFileUrlResolver = new SsrRuntimeFontFileUrlResolver({
+									urls: new Set(${JSON.stringify(urls)}),
+								});
+							`
+            };
+          }
+          return {
+            code: `
+							import { RemoteRuntimeFontFileUrlResolver } from ${JSON.stringify(new URL("./infra/remote-runtime-font-file-url-resolver.js", import.meta.url))};
+							export const runtimeFontFileUrlResolver = new RemoteRuntimeFontFileUrlResolver({
+								urls: new Set(${JSON.stringify(urls)}),
+								address: ${JSON.stringify(serverAddress)},
+							});
+						`
+          };
+        }
       }
     },
     async buildEnd() {
       if (built) {
         return;
       }
-      if (sync || !settings.config.fonts?.length || !isBuild) {
+      if (sync || !settings.config.fonts?.length || this.environment.config.command === "serve") {
         cleanup();
         return;
       }

package/dist/assets/index.d.ts

@@ -1,4 +1,4 @@
-export { getConfiguredImageService, getImage } from './internal.js';
+export { getConfiguredImageService, getImage, verifyOptions } from './internal.js';
 export { baseService, isLocalService } from './services/service.js';
 export { hashTransform, propsToFilename } from './utils/hash.js';
 export type { LocalImageProps, RemoteImageProps } from './types.js';

package/dist/assets/index.js

@@ -1,4 +1,4 @@
-import { getConfiguredImageService, getImage } from "./internal.js";
+import { getConfiguredImageService, getImage, verifyOptions } from "./internal.js";
 import { baseService, isLocalService } from "./services/service.js";
 import { hashTransform, propsToFilename } from "./utils/hash.js";
 export {
@@ -7,5 +7,6 @@ export {
   getImage,
   hashTransform,
   isLocalService,
-  propsToFilename
+  propsToFilename,
+  verifyOptions
 };

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

@@ -0,0 +1,5 @@
+import * as z from 'zod/v4';
+export declare const SvgOptimizerSchema: z.ZodObject<{
+    name: z.ZodString;
+    optimize: z.ZodCustom<(contents: string) => string | Promise<string>, (contents: string) => string | Promise<string>>;
+}, z.core.$strip>;

package/dist/assets/svg/config.js

@@ -0,0 +1,8 @@
+import * as z from "zod/v4";
+const SvgOptimizerSchema = z.object({
+  name: z.string(),
+  optimize: z.custom((v) => typeof v === "function")
+});
+export {
+  SvgOptimizerSchema
+};

package/dist/assets/svg/svgo.d.ts

@@ -0,0 +1,4 @@
+import type { SvgOptimizer } from './types.js';
+import { type Config } from 'svgo';
+/** SVG optimizer using [SVGO](https://svgo.dev/). */
+export declare function svgoOptimizer(config?: Config): SvgOptimizer;

package/dist/assets/svg/svgo.js

@@ -0,0 +1,10 @@
+import { optimize } from "svgo";
+function svgoOptimizer(config) {
+  return {
+    name: "svgo",
+    optimize: (contents) => optimize(contents, config).data
+  };
+}
+export {
+  svgoOptimizer
+};

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

@@ -0,0 +1,4 @@
+export interface SvgOptimizer {
+    name: string;
+    optimize: (contents: string) => string | Promise<string>;
+}

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

@@ -0,0 +1,3 @@
+import type { ImageMetadata } from '../types.js';
+import type { SvgOptimizer } from './types.js';
+export declare function makeSvgComponent(meta: ImageMetadata, contents: Buffer | string, svgOptimizer: SvgOptimizer | undefined): Promise<string>;