astro 6.0.8 → 6.1.0

package/client.d.ts

@@ -30,36 +30,36 @@ interface ImportMeta {
 }
 
 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's type here is different from the internal function since the Vite module implicitly pass the service config
-		/**
-		 * Get an optimized image and the necessary attributes to render it.
-		 *
-		 * **Example**
-		 * ```astro
-		 * ---
-		 * import { getImage } from 'astro:assets';
-		 * import originalImage from '../assets/image.png';
-		 *
-		 * const optimizedImage = await getImage({src: originalImage, width: 1280 });
-		 * ---
-		 * <img src={optimizedImage.src} {...optimizedImage.attributes} />
-		 * ```
-		 *
-		 * This is functionally equivalent to using the `<Image />` component, as the component calls this function internally.
-		 */
-		getImage: (
-			options: import('./dist/assets/types.js').UnresolvedImageTransform,
-		) => Promise<import('./dist/assets/types.js').GetImageResult>;
-		imageConfig: import('./dist/types/public/config.js').AstroConfig['image'];
-		getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;
-		inferRemoteSize: typeof import('./dist/assets/utils/index.js').inferRemoteSize;
-		Image: typeof import('./components/Image.astro').default;
-		Picture: typeof import('./components/Picture.astro').default;
-		Font: typeof import('./components/Font.astro').default;
-		fontData: Record<import('astro:assets').CssVariable, Array<import('astro:assets').FontData>>;
-	};
+	// getImage's type here is different from the internal function since the Vite module implicitly pass the service config
+	/**
+	 * Get an optimized image and the necessary attributes to render it.
+	 *
+	 * **Example**
+	 * ```astro
+	 * ---
+	 * import { getImage } from 'astro:assets';
+	 * import originalImage from '../assets/image.png';
+	 *
+	 * const optimizedImage = await getImage({src: originalImage, width: 1280 });
+	 * ---
+	 * <img src={optimizedImage.src} {...optimizedImage.attributes} />
+	 * ```
+	 *
+	 * This is functionally equivalent to using the `<Image />` component, as the component calls this function internally.
+	 */
+	export const getImage: (
+		options: import('./dist/assets/types.js').UnresolvedImageTransform,
+	) => Promise<import('./dist/assets/types.js').GetImageResult>;
+	export const imageConfig: import('./dist/types/public/config.js').AstroConfig['image'];
+	export const getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;
+	export const inferRemoteSize: typeof import('./dist/assets/utils/index.js').inferRemoteSize;
+	export const Image: typeof import('./components/Image.astro').default;
+	export const Picture: typeof import('./components/Picture.astro').default;
+	export const Font: typeof import('./components/Font.astro').default;
+	export const fontData: Record<
+		import('astro:assets').CssVariable,
+		Array<import('astro:assets').FontData>
+	>;
 
 	type ImgAttributes = import('./dist/type-utils.js').WithRequired<
 		Omit<import('./types').HTMLAttributes<'img'>, 'src' | 'width' | 'height'>,
@@ -72,16 +72,6 @@ declare module 'astro:assets' {
 	export type RemoteImageProps = import('./dist/type-utils.js').Simplify<
 		import('./dist/assets/types.js').RemoteImageProps<ImgAttributes>
 	>;
-	export const {
-		getImage,
-		getConfiguredImageService,
-		imageConfig,
-		Image,
-		Picture,
-		Font,
-		inferRemoteSize,
-		fontData,
-	}: AstroAssets;
 }
 
 declare module 'virtual:astro:image-styles.css' {

package/dist/assets/build/generate.js

@@ -95,12 +95,11 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env) {
         };
       } else {
         const JSONData = JSON.parse(readFileSync(cachedMetaFileURL, "utf-8"));
-        if (!JSONData.expires) {
-          try {
-            await fs.promises.unlink(cachedFileURL);
-          } catch {
-          }
-          await fs.promises.unlink(cachedMetaFileURL);
+        if (typeof JSONData.expires !== "number") {
+          await Promise.allSettled([
+            fs.promises.unlink(cachedFileURL),
+            fs.promises.unlink(cachedMetaFileURL)
+          ]);
           throw new Error(
             `Malformed cache entry for ${filepath}, cache will be regenerated for this file.`
           );
@@ -114,9 +113,7 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env) {
         }
         if (JSONData.expires > Date.now()) {
           await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
-          return {
-            cached: "hit"
-          };
+          return { cached: "hit" };
         }
         if (JSONData.etag || JSONData.lastModified) {
           try {
@@ -124,15 +121,13 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env) {
               etag: JSONData.etag,
               lastModified: JSONData.lastModified
             });
-            if (revalidatedData.data.length) {
+            if (revalidatedData.data !== null) {
               originalImage = revalidatedData;
             } else {
-              await writeCacheMetaFile(cachedMetaFileURL, revalidatedData, env);
-              await fs.promises.copyFile(
-                cachedFileURL,
-                finalFileURL,
-                fs.constants.COPYFILE_FICLONE
-              );
+              await Promise.all([
+                writeCacheMetaFile(cachedMetaFileURL, revalidatedData, env),
+                fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE)
+              ]);
               return { cached: "revalidated" };
             }
           } catch (e) {
@@ -144,8 +139,10 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env) {
             return { cached: "hit" };
           }
         }
-        await fs.promises.unlink(cachedFileURL);
-        await fs.promises.unlink(cachedMetaFileURL);
+        await Promise.allSettled([
+          fs.promises.unlink(cachedFileURL),
+          fs.promises.unlink(cachedMetaFileURL)
+        ]);
       }
     } catch (e) {
       if (e.code !== "ENOENT") {
@@ -219,7 +216,8 @@ async function writeCacheMetaFile(cachedMetaFileURL, resultData, env) {
         expires: resultData.expires,
         etag: resultData.etag,
         lastModified: resultData.lastModified
-      })
+      }),
+      "utf-8"
     );
   } catch (e) {
     env.logger.warn(

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

@@ -4,7 +4,7 @@ export type RemoteCacheEntry = {
     etag?: string;
     lastModified?: string;
 };
-export declare function loadRemoteImage(src: string): Promise<{
+export declare function loadRemoteImage(src: string, fetchFn?: typeof fetch): Promise<{
     data: Buffer<ArrayBuffer>;
     expires: number;
     etag: string | undefined;
@@ -17,13 +17,13 @@ export declare function loadRemoteImage(src: string): Promise<{
  * The remote server may respond that the cached asset is still up-to-date if the entity-tag or modification time matches (304 Not Modified), or respond with an updated asset (200 OK)
  * @param src - url to remote asset
  * @param revalidationData - an object containing the stored Entity-Tag of the cached asset and/or the Last Modified time
- * @returns An ImageData object containing the asset data, a new expiry time, and the asset's etag. The data buffer will be empty if the asset was not modified.
+ * @returns An object containing the refreshed expiry time and cache headers. `data` will be a `Buffer` of the new image if the asset was modified (200 OK), or `null` if the cached version is still valid (304 Not Modified).
  */
 export declare function revalidateRemoteImage(src: string, revalidationData: {
     etag?: string;
     lastModified?: string;
-}): Promise<{
-    data: Buffer<ArrayBuffer>;
+}, fetchFn?: typeof fetch): Promise<{
+    data: Buffer<ArrayBuffer> | null;
     expires: number;
     etag: string | undefined;
     lastModified: string | undefined;

package/dist/assets/build/remote.js

@@ -1,7 +1,7 @@
 import CachePolicy from "http-cache-semantics";
-async function loadRemoteImage(src) {
+async function loadRemoteImage(src, fetchFn = globalThis.fetch) {
   const req = new Request(src);
-  const res = await fetch(req, { redirect: "manual" });
+  const res = await fetchFn(req, { redirect: "manual" });
   if (res.status >= 300 && res.status < 400) {
     throw new Error(`Failed to load remote image ${src}. The request was redirected.`);
   }
@@ -19,35 +19,37 @@ async function loadRemoteImage(src) {
     lastModified: res.headers.get("Last-Modified") ?? void 0
   };
 }
-async function revalidateRemoteImage(src, revalidationData) {
+async function revalidateRemoteImage(src, revalidationData, fetchFn = globalThis.fetch) {
   const headers = {
     ...revalidationData.etag && { "If-None-Match": revalidationData.etag },
     ...revalidationData.lastModified && { "If-Modified-Since": revalidationData.lastModified }
   };
   const req = new Request(src, { headers, cache: "no-cache" });
-  const res = await fetch(req, { redirect: "manual" });
-  if (res.status >= 300 && res.status < 400) {
-    throw new Error(`Failed to revalidate cached remote image ${src}. The request was redirected.`);
-  }
+  const res = await fetchFn(req, { redirect: "manual" });
   if (!res.ok && res.status !== 304) {
+    if (res.status >= 300 && res.status < 400) {
+      throw new Error(
+        `Failed to revalidate cached remote image ${src}. The request was redirected.`
+      );
+    }
     throw new Error(
       `Failed to revalidate cached remote image ${src}. The request did not return a 200 OK / 304 NOT MODIFIED response. (received ${res.status} ${res.statusText})`
     );
   }
   const data = Buffer.from(await res.arrayBuffer());
   if (res.ok && !data.length) {
-    return await loadRemoteImage(src);
+    return await loadRemoteImage(src, fetchFn);
   }
   const policy = new CachePolicy(
     webToCachePolicyRequest(req),
     webToCachePolicyResponse(
       res.ok ? res : new Response(null, { status: 200, headers: res.headers })
     )
-    // 304 responses themselves are not cacheable, so just pretend to get the refreshed TTL
+    // 304 responses are not cacheable, so just use its headers to get the refreshed TTL
   );
   const expires = policy.storable() ? policy.timeToLive() : 0;
   return {
-    data,
+    data: res.ok ? data : null,
     expires: Date.now() + expires,
     // While servers should respond with the same headers as a 200 response, if they don't we should reuse the stored value
     etag: res.headers.get("Etag") ?? (res.ok ? void 0 : revalidationData.etag),

package/dist/assets/fonts/infra/dev-font-file-id-generator.js

@@ -17,6 +17,9 @@ class DevFontFileIdGenerator {
     }
     return weight?.replace(/\s+/g, "-");
   }
+  #formatStyle(style) {
+    return style?.replace(/\s+/g, "-");
+  }
   generate({
     cssVariable,
     originalUrl,
@@ -26,7 +29,7 @@ class DevFontFileIdGenerator {
     return [
       cssVariable.slice(2),
       this.#formatWeight(font.weight),
-      font.style,
+      this.#formatStyle(font.style),
       font.meta?.subset,
       `${this.#hasher.hashString(this.#contentResolver.resolve(originalUrl))}.${type}`
     ].filter(Boolean).join("-");

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

@@ -51,6 +51,7 @@ function fontsPlugin({ settings, sync, logger }) {
   let isBuild;
   let fontFetcher = null;
   let fontTypeExtractor = null;
+  let built = false;
   const cleanup = () => {
     componentDataByCssVariable = null;
     fontDataByCssVariable = null;
@@ -63,6 +64,9 @@ function fontsPlugin({ settings, sync, logger }) {
       isBuild = command === "build";
     },
     async buildStart() {
+      if (sync) {
+        return;
+      }
       const { root } = settings.config;
       const hasher = await XxhashHasher.create();
       const storage = new UnstorageFsStorage({
@@ -252,6 +256,9 @@ function fontsPlugin({ settings, sync, logger }) {
       }
     },
     async buildEnd() {
+      if (built) {
+        return;
+      }
       if (sync || !settings.config.fonts?.length || !isBuild) {
         cleanup();
         return;
@@ -282,6 +289,7 @@ function fontsPlugin({ settings, sync, logger }) {
         }
       } finally {
         cleanup();
+        built = true;
       }
     }
   };

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

@@ -1,5 +1,5 @@
-import type { ResizeOptions, SharpOptions } from 'sharp';
-import { type LocalImageService } from './service.js';
+import type { AvifOptions, JpegOptions, PngOptions, ResizeOptions, SharpOptions, WebpOptions } from 'sharp';
+import { type BaseServiceTransform, type LocalImageService } from './service.js';
 export interface SharpImageServiceConfig {
     /**
      * The `limitInputPixels` option passed to Sharp. See https://sharp.pixelplumbing.com/api-constructor for more information
@@ -9,6 +9,25 @@ export interface SharpImageServiceConfig {
      * The `kernel` option is passed to resize calls. See https://sharp.pixelplumbing.com/api-resize/ for more information
      */
     kernel?: ResizeOptions['kernel'];
+    /**
+     * The default encoder options passed to `sharp().jpeg()`.
+     */
+    jpeg?: JpegOptions;
+    /**
+     * The default encoder options passed to `sharp().png()`.
+     */
+    png?: PngOptions;
+    /**
+     * The default encoder options passed to `sharp().webp()`.
+     */
+    webp?: WebpOptions;
+    /**
+     * The default encoder options passed to `sharp().avif()`.
+     */
+    avif?: AvifOptions;
 }
+export declare function resolveSharpEncoderOptions(transform: Pick<BaseServiceTransform, 'format' | 'quality'>, inputFormat: string | undefined, serviceConfig?: SharpImageServiceConfig): JpegOptions | PngOptions | WebpOptions | AvifOptions | {
+    quality?: number;
+} | undefined;
 declare const sharpService: LocalImageService<SharpImageServiceConfig>;
 export default sharpService;

package/dist/assets/services/sharp.js

@@ -10,6 +10,47 @@ const qualityTable = {
   high: 80,
   max: 100
 };
+function resolveSharpQuality(quality) {
+  if (!quality) return void 0;
+  const parsedQuality = parseQuality(quality);
+  if (typeof parsedQuality === "number") {
+    return parsedQuality;
+  }
+  return quality in qualityTable ? qualityTable[quality] : void 0;
+}
+function resolveSharpEncoderOptions(transform, inputFormat, serviceConfig = {}) {
+  const quality = resolveSharpQuality(transform.quality);
+  switch (transform.format) {
+    case "jpg":
+    case "jpeg":
+      return {
+        ...serviceConfig.jpeg,
+        ...quality === void 0 ? {} : { quality }
+      };
+    case "png":
+      return {
+        ...serviceConfig.png,
+        ...quality === void 0 ? {} : { quality }
+      };
+    case "webp": {
+      const webpOptions = {
+        ...serviceConfig.webp,
+        ...quality === void 0 ? {} : { quality }
+      };
+      if (inputFormat === "gif") {
+        webpOptions.loop ??= 0;
+      }
+      return webpOptions;
+    }
+    case "avif":
+      return {
+        ...serviceConfig.avif,
+        ...quality === void 0 ? {} : { quality }
+      };
+    default:
+      return quality === void 0 ? void 0 : { quality };
+  }
+}
 async function loadSharp() {
   let sharpImport;
   try {
@@ -75,19 +116,19 @@ const sharpService = {
       result.flatten({ background: transform.background });
     }
     if (transform.format) {
-      let quality = void 0;
-      if (transform.quality) {
-        const parsedQuality = parseQuality(transform.quality);
-        if (typeof parsedQuality === "number") {
-          quality = parsedQuality;
-        } else {
-          quality = transform.quality in qualityTable ? qualityTable[transform.quality] : void 0;
-        }
-      }
+      const encoderOptions = resolveSharpEncoderOptions(transform, format, config.service.config);
       if (transform.format === "webp" && format === "gif") {
-        result.webp({ quality: typeof quality === "number" ? quality : void 0, loop: 0 });
+        result.webp(encoderOptions);
+      } else if (transform.format === "webp") {
+        result.webp(encoderOptions);
+      } else if (transform.format === "png") {
+        result.png(encoderOptions);
+      } else if (transform.format === "avif") {
+        result.avif(encoderOptions);
+      } else if (transform.format === "jpeg" || transform.format === "jpg") {
+        result.jpeg(encoderOptions);
       } else {
-        result.toFormat(transform.format, { quality });
+        result.toFormat(transform.format, encoderOptions);
       }
     }
     const { data, info } = await result.toBuffer({ resolveWithObject: true });
@@ -100,5 +141,6 @@ const sharpService = {
 };
 var sharp_default = sharpService;
 export {
-  sharp_default as default
+  sharp_default as default,
+  resolveSharpEncoderOptions
 };

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

@@ -122,7 +122,10 @@ function assets({ fs, settings, sync, logger }) {
           const getImageExport = isServerEnvironment ? `import { getImage as getImageInternal } from "astro/assets";
 							export const getImage = async (options) => await getImageInternal(options, imageConfig);` : `import { AstroError, AstroErrorData } from "astro/errors";
 							export const getImage = async () => {
-								throw new AstroError(AstroErrorData.GetImageNotUsedOnServer);
+								throw new AstroError(
+									AstroErrorData.GetImageNotUsedOnServer.message,
+									AstroErrorData.GetImageNotUsedOnServer.hint,
+								);
 							};`;
           return {
             code: `

package/dist/cli/add/index.js

@@ -207,6 +207,12 @@ async function add(names, { flags }) {
           logger,
           scripts: { "generate-types": "wrangler types" }
         });
+        await updatePackageJsonOverrides({
+          configURL,
+          flags,
+          logger,
+          overrides: { vite: "^7" }
+        });
       }
       if (integrations.find((integration) => integration.id === "tailwind")) {
         const dir = new URL("./styles/", new URL(userConfig.srcDir ?? "./src/", root));
@@ -601,6 +607,54 @@ async function updateAstroConfig({
     return 2 /* cancelled */;
   }
 }
+async function updatePackageJsonOverrides({
+  configURL,
+  flags,
+  logger,
+  overrides
+}) {
+  const pkgURL = new URL("./package.json", configURL);
+  if (!existsSync(pkgURL)) {
+    logger.debug("add", "No package.json found, skipping overrides update");
+    return 0 /* none */;
+  }
+  const pkgPath = fileURLToPath(pkgURL);
+  const input = await fs.readFile(pkgPath, { encoding: "utf-8" });
+  const pkgJson = JSON.parse(input);
+  pkgJson.overrides ??= {};
+  let hasChanges = false;
+  for (const [name, range] of Object.entries(overrides)) {
+    if (!(name in pkgJson.overrides)) {
+      pkgJson.overrides[name] = range;
+      hasChanges = true;
+    }
+  }
+  if (!hasChanges) {
+    return 0 /* none */;
+  }
+  const output = JSON.stringify(pkgJson, null, 2);
+  const diff = getDiffContent(input, output);
+  if (!diff) {
+    return 0 /* none */;
+  }
+  logger.info(
+    "SKIP_FORMAT",
+    `
+  ${magenta("Astro will add the following overrides to your package.json:")}`
+  );
+  clack.box(diff, "package.json", {
+    rounded: true,
+    withGuide: false,
+    width: "auto"
+  });
+  if (await askToContinue({ flags, logger })) {
+    await fs.writeFile(pkgPath, output, { encoding: "utf-8" });
+    logger.debug("add", "Updated package.json overrides");
+    return 1 /* updated */;
+  } else {
+    return 2 /* cancelled */;
+  }
+}
 async function updatePackageJsonScripts({
   configURL,
   flags,

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "6.0.8";
+  version = "6.1.0";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

@@ -192,7 +192,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.0.8") {
+    if (previousAstroVersion && previousAstroVersion !== "6.1.0") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -200,8 +200,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.0.8") {
-      this.#store.metaStore().set("astro-version", "6.0.8");
+    if ("6.1.0") {
+      this.#store.metaStore().set("astro-version", "6.1.0");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/index.d.ts

@@ -1,6 +1,6 @@
 export { attachContentServerListeners } from './server-listeners.js';
 export { createContentTypesGenerator } from './types-generator.js';
-export { getContentPaths, hasAssetPropagationFlag } from './utils.js';
+export { getContentPaths } from './utils.js';
 export { astroContentAssetPropagationPlugin } from './vite-plugin-content-assets.js';
 export { astroContentImportPlugin } from './vite-plugin-content-imports.js';
 export { astroContentVirtualModPlugin } from './vite-plugin-content-virtual-mod.js';

package/dist/content/index.js

@@ -1,6 +1,6 @@
 import { attachContentServerListeners } from "./server-listeners.js";
 import { createContentTypesGenerator } from "./types-generator.js";
-import { getContentPaths, hasAssetPropagationFlag } from "./utils.js";
+import { getContentPaths } from "./utils.js";
 import { astroContentAssetPropagationPlugin } from "./vite-plugin-content-assets.js";
 import { astroContentImportPlugin } from "./vite-plugin-content-imports.js";
 import { astroContentVirtualModPlugin } from "./vite-plugin-content-virtual-mod.js";
@@ -10,6 +10,5 @@ export {
   astroContentVirtualModPlugin,
   attachContentServerListeners,
   createContentTypesGenerator,
-  getContentPaths,
-  hasAssetPropagationFlag
+  getContentPaths
 };

package/dist/content/runtime.d.ts

@@ -1,6 +1,7 @@
 import type { MarkdownHeading } from '@astrojs/markdown-remark';
 import * as z from 'zod/v4';
 import type * as zCore from 'zod/v4/core';
+import type { ImageMetadata } from '../assets/types.js';
 import { type AstroComponentFactory } from '../runtime/server/index.js';
 import type { LiveDataCollectionResult, LiveDataEntryResult } from '../types/public/content.js';
 import { type LIVE_CONTENT_TYPE } from './consts.js';
@@ -67,6 +68,7 @@ type RenderResult = {
     headings: MarkdownHeading[];
     remarkPluginFrontmatter: Record<string, any>;
 };
+export declare function updateImageReferencesInData<T extends Record<string, unknown>>(data: T, fileName?: string, imageAssetMap?: Map<string, ImageMetadata>): T;
 export declare function renderEntry(entry: DataEntry): Promise<RenderResult>;
 export declare function createReference(): (collection: string) => z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     id: z.ZodString;

package/dist/content/runtime.js

@@ -554,5 +554,6 @@ export {
   createReference,
   defineCollection,
   defineLiveCollection,
-  renderEntry
+  renderEntry,
+  updateImageReferencesInData
 };

package/dist/content/types-generator.js

@@ -450,9 +450,13 @@ async function generateJSONSchema(fsMod, collectionConfig, collectionKey, collec
     zodSchemaForJson = z.object({}).catchall(zodSchemaForJson);
   }
   if (zodSchemaForJson instanceof z.ZodObject) {
+    const existingMeta = z.globalRegistry.get(zodSchemaForJson);
     zodSchemaForJson = zodSchemaForJson.extend({
       $schema: z.string().optional()
     });
+    if (existingMeta) {
+      z.globalRegistry.add(zodSchemaForJson, existingMeta);
+    }
   }
   try {
     const schema = z.toJSONSchema(zodSchemaForJson, {

package/dist/content/utils.d.ts

@@ -187,7 +187,6 @@ export declare function getEntrySlug({ id, collection, generatedSlug, contentEnt
     fileUrl: URL;
     contentEntryType: Pick<ContentEntryType, 'getEntryInfo'>;
 }): Promise<string>;
-export declare function hasAssetPropagationFlag(id: string): boolean;
 /**
  * Unlike `path.posix.relative`, this function will accept a platform path and return a posix path.
  */

package/dist/content/utils.js

@@ -15,8 +15,7 @@ import {
   CONTENT_MODULE_FLAG,
   DEFERRED_MODULE,
   IMAGE_IMPORT_PREFIX,
-  LIVE_CONTENT_TYPE,
-  PROPAGATED_ASSET_FLAG
+  LIVE_CONTENT_TYPE
 } from "./consts.js";
 import { glob, secretLegacyFlag } from "./loaders/glob.js";
 import { createImage } from "./runtime-assets.js";
@@ -620,13 +619,6 @@ function globWithUnderscoresIgnored(relContentDir, exts) {
     `!${contentDir}**/_*${extGlob}`
   ];
 }
-function hasAssetPropagationFlag(id) {
-  try {
-    return new URL(id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG);
-  } catch {
-    return false;
-  }
-}
 function posixifyPath(filePath) {
   return filePath.split(path.sep).join("/");
 }
@@ -674,7 +666,6 @@ export {
   getEntryType,
   getSymlinkedContentCollections,
   globalContentConfigObserver,
-  hasAssetPropagationFlag,
   hasContentFlag,
   isDeferredModule,
   loaderReturnSchema,

package/dist/core/app/dev/app.d.ts

@@ -9,6 +9,11 @@ export declare class DevApp extends BaseApp<NonRunnablePipeline> {
     constructor(manifest: SSRManifest, streaming: boolean | undefined, logger: Logger);
     createPipeline(streaming: boolean, manifest: SSRManifest, logger: Logger): NonRunnablePipeline;
     isDev(): boolean;
+    /**
+     * Clears the cached middleware so it is re-resolved on the next request.
+     * Called via HMR when middleware files change.
+     */
+    clearMiddleware(): void;
     /**
      * Updates the routes list when files change during development.
      * Called via HMR when new pages are added/removed.