astro 2.1.1 → 2.1.3

package/client-base.d.ts

@@ -4,6 +4,7 @@ declare module 'astro:assets' {
 	// Exporting things one by one is a bit cumbersome, not sure if there's a better way - erika, 2023-02-03
 	type AstroAssets = {
 		getImage: typeof import('./dist/assets/index.js').getImage;
+		getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;
 		Image: typeof import('./components/Image.astro').default;
 	};
 
@@ -20,7 +21,7 @@ declare module 'astro:assets' {
 	export type RemoteImageProps = Simplify<
 		import('./dist/assets/types.js').RemoteImageProps<ImgAttributes>
 	>;
-	export const { getImage, Image }: AstroAssets;
+	export const { getImage, getConfiguredImageService, Image }: AstroAssets;
 }
 
 type MD = import('./dist/@types/astro').MarkdownInstance<Record<string, any>>;

package/client-image.d.ts

@@ -1,6 +1,8 @@
 /// <reference path="./client-base.d.ts" />
 
-type InputFormat = 'avif' | 'gif' | 'heic' | 'heif' | 'jpeg' | 'jpg' | 'png' | 'tiff' | 'webp';
+// TODO: Merge this file with `client-base.d.ts` in 3.0, when the `astro:assets` feature isn't under a flag anymore.
+
+type InputFormat = import('./dist/assets/types.js').InputFormat;
 
 interface ImageMetadata {
 	src: string;
@@ -9,23 +11,10 @@ interface ImageMetadata {
 	format: InputFormat;
 }
 
-// images
-declare module '*.avif' {
-	const metadata: ImageMetadata;
-	export default metadata;
-}
 declare module '*.gif' {
 	const metadata: ImageMetadata;
 	export default metadata;
 }
-declare module '*.heic' {
-	const metadata: ImageMetadata;
-	export default metadata;
-}
-declare module '*.heif' {
-	const metadata: ImageMetadata;
-	export default metadata;
-}
 declare module '*.jpeg' {
 	const metadata: ImageMetadata;
 	export default metadata;
@@ -46,3 +35,7 @@ declare module '*.webp' {
 	const metadata: ImageMetadata;
 	export default metadata;
 }
+declare module '*.svg' {
+	const metadata: ImageMetadata;
+	export default metadata;
+}

package/dist/@types/astro.d.ts

@@ -15,10 +15,10 @@ import type { AstroTimer } from '../core/config/timer';
 import type { AstroCookies } from '../core/cookies';
 import type { LogOptions } from '../core/logger/core';
 import type { AstroComponentFactory, AstroComponentInstance } from '../runtime/server';
-import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from './../core/constants.js';
+import type { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from './../core/constants.js';
 export type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, RehypePlugins, RemarkPlugins, ShikiConfig, } from '@astrojs/markdown-remark';
 export type { ExternalImageService, LocalImageService } from '../assets/services/service';
-export type { ImageTransform } from '../assets/types';
+export type { ImageMetadata, ImageTransform } from '../assets/types';
 export type { SSRManifest } from '../core/app/types';
 export type { AstroCookies } from '../core/cookies';
 export interface AstroBuiltinProps {

package/dist/assets/consts.d.ts

@@ -1,4 +1,8 @@
 export declare const VIRTUAL_MODULE_ID = "astro:assets";
 export declare const VIRTUAL_SERVICE_ID = "virtual:image-service";
-export declare const VALID_INPUT_FORMATS: readonly ["heic", "heif", "avif", "jpeg", "jpg", "png", "tiff", "webp", "gif"];
+/**
+ * Valid formats for optimizations in our base services.
+ * Certain formats can be imported (namely SVGs) but not optimized, so they are excluded from this list.
+ */
+export declare const VALID_INPUT_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif"];
 export declare const VALID_OUTPUT_FORMATS: readonly ["avif", "png", "webp", "jpeg", "jpg"];

package/dist/assets/consts.js

@@ -1,9 +1,6 @@
 const VIRTUAL_MODULE_ID = "astro:assets";
 const VIRTUAL_SERVICE_ID = "virtual:image-service";
 const VALID_INPUT_FORMATS = [
-  "heic",
-  "heif",
-  "avif",
   "jpeg",
   "jpg",
   "png",

package/dist/assets/internal.d.ts

@@ -1,4 +1,4 @@
-import { StaticBuildOptions } from '../core/build/types.js';
+import type { StaticBuildOptions } from '../core/build/types.js';
 import { ImageService } from './services/service.js';
 import type { ImageMetadata, ImageTransform } from './types.js';
 export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;

package/dist/assets/services/service.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { ImageTransform, OutputFormat } from '../types.js';
+import type { ImageTransform, OutputFormat } from '../types.js';
 export type ImageService = LocalImageService | ExternalImageService;
 export declare function isLocalService(service: ImageService | undefined): service is LocalImageService;
 export declare function parseQuality(quality: string): string | number;
@@ -63,8 +63,10 @@ export type BaseServiceTransform = {
  * }
  * ```
  *
- * This service only supports the following properties: `width`, `height`, `format` and `quality`.
- * Additionally, remote URLs are passed as-is.
+ * This service adhere to the included services limitations:
+ * - Remote images are passed as is.
+ * - Only a limited amount of formats are supported.
+ * - For remote images, `width` and `height` are always required.
  *
  */
 export declare const baseService: Omit<LocalImageService, 'transform'>;

package/dist/assets/types.d.ts

@@ -1,8 +1,8 @@
-import { VALID_INPUT_FORMATS, VALID_OUTPUT_FORMATS } from './consts.js';
-import { ImageService } from './services/service.js';
+import type { VALID_INPUT_FORMATS, VALID_OUTPUT_FORMATS } from './consts.js';
+import type { ImageService } from './services/service.js';
 export type ImageQualityPreset = 'low' | 'mid' | 'high' | 'max' | (string & {});
 export type ImageQuality = ImageQualityPreset | number;
-export type InputFormat = (typeof VALID_INPUT_FORMATS)[number] | (string & {});
+export type InputFormat = (typeof VALID_INPUT_FORMATS)[number] | 'svg';
 export type OutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
 declare global {
     var astroAsset: {

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

@@ -0,0 +1,2 @@
+import type { AstroSettings } from '../../@types/astro';
+export declare function emitESMImage(id: string, watchMode: boolean, fileEmitter: any, settings: AstroSettings): Promise<import("./metadata.js").Metadata | undefined>;

package/dist/assets/utils/emitAsset.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { rootRelativePath } from "../../core/util.js";
+import { imageMetadata } from "./metadata.js";
+async function emitESMImage(id, watchMode, fileEmitter, settings) {
+  const url = pathToFileURL(id);
+  const meta = await imageMetadata(url);
+  if (!meta) {
+    return;
+  }
+  if (!watchMode) {
+    const pathname = decodeURI(url.pathname);
+    const filename = path.basename(pathname, path.extname(pathname) + `.${meta.format}`);
+    const handle = fileEmitter({
+      name: filename,
+      source: await fs.promises.readFile(url),
+      type: "asset"
+    });
+    meta.src = `__ASTRO_ASSET_IMAGE__${handle}__`;
+  } else {
+    url.searchParams.append("origWidth", meta.width.toString());
+    url.searchParams.append("origHeight", meta.height.toString());
+    url.searchParams.append("origFormat", meta.format);
+    meta.src = rootRelativePath(settings.config, url);
+  }
+  return meta;
+}
+export {
+  emitESMImage
+};

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { ImageMetadata } from '../types.js';
+import type { ImageMetadata } from '../types.js';
 export interface Metadata extends ImageMetadata {
     orientation?: number;
 }

package/dist/assets/utils/metadata.js

@@ -1,9 +1,10 @@
-import { createRequire } from "module";
 import fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-const require2 = createRequire(import.meta.url);
-const sizeOf = require2("image-size");
+let sizeOf;
 async function imageMetadata(src, data) {
+  if (!sizeOf) {
+    sizeOf = await import("image-size").then((mod) => mod.default);
+  }
   let file = data;
   if (!file) {
     try {

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

@@ -1,2 +1,2 @@
-import { ImageMetadata } from '../types.js';
+import type { ImageMetadata } from '../types.js';
 export declare function getOrigQueryParams(params: URLSearchParams): Omit<ImageMetadata, 'src'> | undefined;

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

@@ -1,2 +1,2 @@
-import { ImageTransform } from '../types.js';
+import type { ImageTransform } from '../types.js';
 export declare function propsToFilename(transform: ImageTransform): string;

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

@@ -1,5 +1,5 @@
 import type * as vite from 'vite';
-import { AstroPluginOptions } from '../@types/astro';
+import type { AstroPluginOptions } from '../@types/astro';
 export default function assets({ settings, logging, mode, }: AstroPluginOptions & {
     mode: string;
 }): vite.Plugin[];

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

@@ -1,17 +1,17 @@
+import { bold } from "kleur/colors";
 import MagicString from "magic-string";
 import mime from "mime";
 import fs from "node:fs/promises";
-import path from "node:path";
 import { Readable } from "node:stream";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import { normalizePath } from "vite";
 import { error } from "../core/logger/core.js";
 import { joinPaths, prependForwardSlash } from "../core/path.js";
-import { rootRelativePath } from "../core/util.js";
 import { VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
 import { isESMImportedImage } from "./internal.js";
 import { isLocalService } from "./services/service.js";
 import { copyWasmFiles } from "./services/vendor/squoosh/copy-wasm.js";
+import { emitESMImage } from "./utils/emitAsset.js";
 import { imageMetadata } from "./utils/metadata.js";
 import { getOrigQueryParams } from "./utils/queryParams.js";
 import { propsToFilename } from "./utils/transformToPath.js";
@@ -21,8 +21,27 @@ function assets({
   logging,
   mode
 }) {
+  var _a;
   let resolvedConfig;
   globalThis.astroAsset = {};
+  const UNSUPPORTED_ADAPTERS = /* @__PURE__ */ new Set([
+    "@astrojs/cloudflare",
+    "@astrojs/deno",
+    "@astrojs/netlify/edge-functions",
+    "@astrojs/vercel/edge"
+  ]);
+  const adapterName = (_a = settings.config.adapter) == null ? void 0 : _a.name;
+  if (["astro/assets/services/sharp", "astro/assets/services/squoosh"].includes(
+    settings.config.image.service
+  ) && adapterName && UNSUPPORTED_ADAPTERS.has(adapterName)) {
+    error(
+      logging,
+      "assets",
+      `The currently selected adapter \`${adapterName}\` does not run on Node, however the currently used image service depends on Node built-ins. ${bold(
+        "Your project will NOT be able to build."
+      )}`
+    );
+  }
   return [
     {
       name: "astro:assets",
@@ -56,8 +75,8 @@ function assets({
       },
       configureServer(server) {
         server.middlewares.use(async (req, res, next) => {
-          var _a;
-          if ((_a = req.url) == null ? void 0 : _a.startsWith("/_image")) {
+          var _a2;
+          if ((_a2 = req.url) == null ? void 0 : _a2.startsWith("/_image")) {
             if (!isLocalService(globalThis.astroAsset.imageService)) {
               return next();
             }
@@ -66,8 +85,8 @@ function assets({
             if (!filePath) {
               return next();
             }
-            const filePathURL = new URL(filePath, "file:");
-            const file = await fs.readFile(filePathURL.pathname);
+            const filePathURL = new URL("." + filePath, settings.config.root);
+            const file = await fs.readFile(filePathURL);
             let meta = getOrigQueryParams(filePathURL.searchParams);
             if (!meta) {
               meta = await imageMetadata(filePathURL, file);
@@ -86,7 +105,10 @@ function assets({
               data = result.data;
               format = result.format;
             }
-            res.setHeader("Content-Type", mime.getType(fileURLToPath(url)) || `image/${format}`);
+            res.setHeader(
+              "Content-Type",
+              mime.getType(fileURLToPath(filePathURL)) || `image/${format}`
+            );
             res.setHeader("Cache-Control", "max-age=360000");
             const stream = Readable.from(data);
             return stream.pipe(res);
@@ -157,26 +179,7 @@ function assets({
       },
       async load(id) {
         if (/\.(jpeg|jpg|png|tiff|webp|gif|svg)$/.test(id)) {
-          const url = pathToFileURL(id);
-          const meta = await imageMetadata(url);
-          if (!meta) {
-            return;
-          }
-          if (!this.meta.watchMode) {
-            const pathname = decodeURI(url.pathname);
-            const filename = path.basename(pathname, path.extname(pathname) + `.${meta.format}`);
-            const handle = this.emitFile({
-              name: filename,
-              source: await fs.readFile(url),
-              type: "asset"
-            });
-            meta.src = `__ASTRO_ASSET_IMAGE__${handle}__`;
-          } else {
-            url.searchParams.append("origWidth", meta.width.toString());
-            url.searchParams.append("origHeight", meta.height.toString());
-            url.searchParams.append("origFormat", meta.format);
-            meta.src = rootRelativePath(settings.config, url);
-          }
+          const meta = await emitESMImage(id, this.meta.watchMode, this.emitFile, settings);
           return `export default ${JSON.stringify(meta)}`;
         }
       }

package/dist/content/error-map.d.ts

@@ -0,0 +1,2 @@
+import type { ZodErrorMap } from 'zod';
+export declare const errorMap: ZodErrorMap;

package/dist/content/error-map.js

@@ -0,0 +1,75 @@
+const errorMap = (baseError, ctx) => {
+  const baseErrorPath = flattenErrorPath(baseError.path);
+  if (baseError.code === "invalid_union") {
+    let typeOrLiteralErrByPath = /* @__PURE__ */ new Map();
+    for (const unionError of baseError.unionErrors.map((e) => e.errors).flat()) {
+      if (unionError.code === "invalid_type" || unionError.code === "invalid_literal") {
+        const flattenedErrorPath = flattenErrorPath(unionError.path);
+        if (typeOrLiteralErrByPath.has(flattenedErrorPath)) {
+          typeOrLiteralErrByPath.get(flattenedErrorPath).expected.push(unionError.expected);
+        } else {
+          typeOrLiteralErrByPath.set(flattenedErrorPath, {
+            code: unionError.code,
+            received: unionError.received,
+            expected: [unionError.expected]
+          });
+        }
+      }
+    }
+    let messages = [
+      prefix(
+        baseErrorPath,
+        typeOrLiteralErrByPath.size ? "Did not match union:" : "Did not match union."
+      )
+    ];
+    return {
+      message: messages.concat(
+        [...typeOrLiteralErrByPath.entries()].filter(([, error]) => error.expected.length === baseError.unionErrors.length).map(
+          ([key, error]) => key === baseErrorPath ? `> ${getTypeOrLiteralMsg(error)}` : `> ${prefix(key, getTypeOrLiteralMsg(error))}`
+        )
+      ).join("\n")
+    };
+  }
+  if (baseError.code === "invalid_literal" || baseError.code === "invalid_type") {
+    return {
+      message: prefix(
+        baseErrorPath,
+        getTypeOrLiteralMsg({
+          code: baseError.code,
+          received: baseError.received,
+          expected: [baseError.expected]
+        })
+      )
+    };
+  } else if (baseError.message) {
+    return { message: prefix(baseErrorPath, baseError.message) };
+  } else {
+    return { message: prefix(baseErrorPath, ctx.defaultError) };
+  }
+};
+const getTypeOrLiteralMsg = (error) => {
+  if (error.received === "undefined")
+    return "Required";
+  const expectedDeduped = new Set(error.expected);
+  switch (error.code) {
+    case "invalid_type":
+      return `Expected type \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+        error.received
+      )}`;
+    case "invalid_literal":
+      return `Expected \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+        error.received
+      )}`;
+  }
+};
+const prefix = (key, msg) => key.length ? `**${key}**: ${msg}` : msg;
+const unionExpectedVals = (expectedVals) => [...expectedVals].map((expectedVal, idx) => {
+  if (idx === 0)
+    return JSON.stringify(expectedVal);
+  const sep = " | ";
+  return `${sep}${JSON.stringify(expectedVal)}`;
+}).join("");
+const flattenErrorPath = (errorPath) => errorPath.join(".");
+export {
+  errorMap
+};

package/dist/content/index.d.ts

@@ -1,3 +1,4 @@
+export { errorMap } from './error-map.js';
 export { attachContentServerListeners } from './server-listeners.js';
 export { createContentTypesGenerator } from './types-generator.js';
 export { contentObservable, getContentPaths, getDotAstroTypeReference } from './utils.js';

package/dist/content/index.js

@@ -1,3 +1,4 @@
+import { errorMap } from "./error-map.js";
 import { attachContentServerListeners } from "./server-listeners.js";
 import { createContentTypesGenerator } from "./types-generator.js";
 import { contentObservable, getContentPaths, getDotAstroTypeReference } from "./utils.js";
@@ -11,6 +12,7 @@ export {
   attachContentServerListeners,
   contentObservable,
   createContentTypesGenerator,
+  errorMap,
   getContentPaths,
   getDotAstroTypeReference
 };

package/dist/content/runtime-assets.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { type Metadata } from '../assets/utils/metadata.js';
+export declare function createImage(options: {
+    assetsDir: string;
+    relAssetsDir: string;
+}): () => z.ZodEffects<z.ZodString, (Metadata & {
+    __astro_asset: true;
+}) | undefined, string>;

package/dist/content/runtime-assets.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { imageMetadata } from "../assets/utils/metadata.js";
+function createImage(options) {
+  return () => {
+    if (options.assetsDir === "undefined") {
+      throw new Error("Enable `experimental.assets` in your Astro config to use image()");
+    }
+    return z.string().transform(async (imagePath) => {
+      const fullPath = new URL(imagePath, options.assetsDir);
+      return await getImageMetadata(fullPath);
+    });
+  };
+}
+async function getImageMetadata(imagePath) {
+  const meta = await imageMetadata(imagePath);
+  if (!meta) {
+    return void 0;
+  }
+  delete meta.orientation;
+  return { ...meta, __astro_asset: true };
+}
+export {
+  createImage
+};

package/dist/content/{internal.d.ts → runtime.d.ts}

@@ -1,5 +1,3 @@
-import { z } from 'zod';
-import { type Metadata } from '../assets/utils/metadata.js';
 type GlobResult = Record<string, () => Promise<any>>;
 type CollectionToEntryMap = Record<string, GlobResult>;
 export declare function createCollectionToGlobResultMap({ globResult, contentDir, }: {
@@ -9,18 +7,7 @@ export declare function createCollectionToGlobResultMap({ globResult, contentDir
 export declare function createGetCollection({ collectionToEntryMap, collectionToRenderEntryMap, }: {
     collectionToEntryMap: CollectionToEntryMap;
     collectionToRenderEntryMap: CollectionToEntryMap;
-}): (collection: string, filter?: ((entry: any) => unknown) | undefined) => Promise<{
-    id: any;
-    slug: any;
-    body: any;
-    collection: any;
-    data: any;
-    render(): Promise<{
-        Content: import("../runtime/server/index.js").AstroComponentFactory;
-        headings: any;
-        remarkPluginFrontmatter: any;
-    }>;
-}[]>;
+}): (collection: string, filter?: ((entry: any) => unknown) | undefined) => Promise<any[]>;
 export declare function createGetEntryBySlug({ getCollection, collectionToRenderEntryMap, }: {
     getCollection: ReturnType<typeof createGetCollection>;
     collectionToRenderEntryMap: CollectionToEntryMap;
@@ -36,9 +23,4 @@ export declare function createGetEntryBySlug({ getCollection, collectionToRender
         remarkPluginFrontmatter: any;
     }>;
 } | undefined>;
-export declare function createImage(options: {
-    assetsDir: string;
-}): () => z.ZodEffects<z.ZodString, (Metadata & {
-    __astro_asset: true;
-}) | undefined, string>;
 export {};

package/dist/content/{internal.js → runtime.js}

@@ -1,5 +1,3 @@
-import { z } from "zod";
-import { imageMetadata } from "../assets/utils/metadata.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { prependForwardSlash } from "../core/path.js";
 import {
@@ -30,33 +28,40 @@ function createCollectionToGlobResultMap({
   }
   return collectionToGlobResultMap;
 }
+const cacheEntriesByCollection = /* @__PURE__ */ new Map();
 function createGetCollection({
   collectionToEntryMap,
   collectionToRenderEntryMap
 }) {
   return async function getCollection(collection, filter) {
     const lazyImports = Object.values(collectionToEntryMap[collection] ?? {});
-    const entries = Promise.all(
-      lazyImports.map(async (lazyImport) => {
-        const entry = await lazyImport();
-        return {
-          id: entry.id,
-          slug: entry.slug,
-          body: entry.body,
-          collection: entry.collection,
-          data: entry.data,
-          async render() {
-            return render({
-              collection: entry.collection,
-              id: entry.id,
-              collectionToRenderEntryMap
-            });
-          }
-        };
-      })
-    );
+    let entries = [];
+    if (import.meta.env.PROD && cacheEntriesByCollection.has(collection)) {
+      entries = cacheEntriesByCollection.get(collection);
+    } else {
+      entries = await Promise.all(
+        lazyImports.map(async (lazyImport) => {
+          const entry = await lazyImport();
+          return {
+            id: entry.id,
+            slug: entry.slug,
+            body: entry.body,
+            collection: entry.collection,
+            data: entry.data,
+            async render() {
+              return render({
+                collection: entry.collection,
+                id: entry.id,
+                collectionToRenderEntryMap
+              });
+            }
+          };
+        })
+      );
+      cacheEntriesByCollection.set(collection, entries);
+    }
     if (typeof filter === "function") {
-      return (await entries).filter(filter);
+      return entries.filter(filter);
     } else {
       return entries;
     }
@@ -159,28 +164,8 @@ async function render({
     remarkPluginFrontmatter: mod.frontmatter ?? {}
   };
 }
-function createImage(options) {
-  return () => {
-    if (options.assetsDir === "undefined") {
-      throw new Error("Enable `experimental.assets` in your Astro config to use image()");
-    }
-    return z.string().transform(async (imagePath) => {
-      const fullPath = new URL(imagePath, options.assetsDir);
-      return await getImageMetadata(fullPath);
-    });
-  };
-}
-async function getImageMetadata(imagePath) {
-  const meta = await imageMetadata(imagePath);
-  if (!meta) {
-    return void 0;
-  }
-  delete meta.orientation;
-  return { ...meta, __astro_asset: true };
-}
 export {
   createCollectionToGlobResultMap,
   createGetCollection,
-  createGetEntryBySlug,
-  createImage
+  createGetEntryBySlug
 };

package/dist/content/template/virtual-mod-assets.d.mts

@@ -0,0 +1 @@
+export const image: any;

package/dist/content/template/virtual-mod.d.mts

@@ -1,4 +1,3 @@
 export function defineCollection(config: any): any;
 export const getCollection: any;
 export const getEntryBySlug: any;
-export const image: any;

package/dist/content/utils.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 import matter from 'gray-matter';
 import fsMod from 'node:fs';
+import type { EmitFile } from 'rollup';
 import { ViteDevServer } from 'vite';
 import { z } from 'zod';
-import { AstroConfig, AstroSettings } from '../@types/astro.js';
+import type { AstroConfig, AstroSettings } from '../@types/astro.js';
 export declare const collectionConfigParser: z.ZodObject<{
     schema: z.ZodOptional<z.ZodAny>;
 }, "strip", z.ZodTypeAny, {
@@ -46,7 +47,10 @@ export type EntryInfo = {
 export declare const msg: {
     collectionConfigMissing: (collection: string) => string;
 };
-export declare function extractFrontmatterAssets(data: Record<string, any>): string[];
+/**
+ * Mutate (arf) the entryData to reroute assets to their final paths
+ */
+export declare function patchAssets(frontmatterEntry: Record<string, any>, watchMode: boolean, fileEmitter: EmitFile, astroSettings: AstroSettings): Promise<void>;
 export declare function getEntrySlug({ id, collection, slug, unvalidatedSlug, }: EntryInfo & {
     unvalidatedSlug?: unknown;
 }): string;
@@ -106,6 +110,7 @@ export type ContentPaths = {
     cacheDir: URL;
     typesTemplate: URL;
     virtualModTemplate: URL;
+    virtualAssetsModTemplate: URL;
     config: {
         exists: boolean;
         url: URL;