astro 3.4.4 → 3.5.1

package/dist/assets/consts.d.ts

@@ -8,3 +8,4 @@ export declare const VALID_INPUT_FORMATS: readonly ["jpeg", "jpg", "png", "tiff"
 export declare const VALID_SUPPORTED_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif", "svg", "avif"];
 export declare const DEFAULT_OUTPUT_FORMAT: "webp";
 export declare const VALID_OUTPUT_FORMATS: readonly ["avif", "png", "webp", "jpeg", "jpg", "svg"];
+export declare const DEFAULT_HASH_PROPS: string[];

package/dist/assets/consts.js

@@ -22,7 +22,9 @@ const VALID_SUPPORTED_FORMATS = [
 ];
 const DEFAULT_OUTPUT_FORMAT = "webp";
 const VALID_OUTPUT_FORMATS = ["avif", "png", "webp", "jpeg", "jpg", "svg"];
+const DEFAULT_HASH_PROPS = ["src", "width", "height", "format", "quality"];
 export {
+  DEFAULT_HASH_PROPS,
   DEFAULT_OUTPUT_FORMAT,
   VALID_INPUT_FORMATS,
   VALID_OUTPUT_FORMATS,

package/dist/assets/endpoint/generic.js

@@ -9,7 +9,7 @@ async function loadRemoteImage(src) {
     if (!res.ok) {
       return void 0;
     }
-    return Buffer.from(await res.arrayBuffer());
+    return await res.arrayBuffer();
   } catch (err) {
     return void 0;
   }
@@ -34,7 +34,11 @@ const GET = async ({ request }) => {
     if (!inputBuffer) {
       return new Response("Not Found", { status: 404 });
     }
-    const { data, format } = await imageService.transform(inputBuffer, transform, imageConfig);
+    const { data, format } = await imageService.transform(
+      new Uint8Array(inputBuffer),
+      transform,
+      imageConfig
+    );
     return new Response(data, {
       status: 200,
       headers: {

package/dist/assets/internal.js

@@ -1,5 +1,6 @@
 import { isRemotePath } from "@astrojs/internal-helpers/path";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { DEFAULT_HASH_PROPS } from "./consts.js";
 import { isLocalService } from "./services/service.js";
 import { matchHostname, matchPattern } from "./utils/remotePattern.js";
 function injectImageEndpoint(settings, mode) {
@@ -55,6 +56,11 @@ async function getImage(options, imageConfig) {
     ...options,
     src: typeof options.src === "object" && "then" in options.src ? (await options.src).default ?? await options.src : options.src
   };
+  const clonedSrc = isESMImportedImage(resolvedOptions.src) ? (
+    // @ts-expect-error - clone is a private, hidden prop
+    resolvedOptions.src.clone ?? resolvedOptions.src
+  ) : resolvedOptions.src;
+  resolvedOptions.src = clonedSrc;
   const validatedOptions = service.validateOptions ? await service.validateOptions(resolvedOptions, imageConfig) : resolvedOptions;
   const srcSetTransforms = service.getSrcSet ? await service.getSrcSet(validatedOptions, imageConfig) : [];
   let imageURL = await service.getURL(validatedOptions, imageConfig);
@@ -67,10 +73,11 @@ async function getImage(options, imageConfig) {
     }))
   );
   if (isLocalService(service) && globalThis.astroAsset.addStaticImage && !(isRemoteImage(validatedOptions.src) && imageURL === validatedOptions.src)) {
-    imageURL = globalThis.astroAsset.addStaticImage(validatedOptions);
+    const propsToHash = service.propertiesToHash ?? DEFAULT_HASH_PROPS;
+    imageURL = globalThis.astroAsset.addStaticImage(validatedOptions, propsToHash);
     srcSets = srcSetTransforms.map((srcSet) => ({
       transform: srcSet.transform,
-      url: globalThis.astroAsset.addStaticImage(srcSet.transform),
+      url: globalThis.astroAsset.addStaticImage(srcSet.transform, propsToHash),
       descriptor: srcSet.descriptor,
       attributes: srcSet.attributes
     }));

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

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { AstroConfig } from '../../@types/astro.js';
 import type { ImageOutputFormat, ImageTransform, UnresolvedSrcSetValue } from '../types.js';
 export type ImageService = LocalImageService | ExternalImageService;
@@ -60,10 +59,16 @@ export interface LocalImageService<T extends Record<string, any> = Record<string
      * Performs the image transformations on the input image and returns both the binary data and
      * final image format of the optimized image.
      */
-    transform: (inputBuffer: Buffer, transform: LocalImageTransform, imageConfig: ImageConfig<T>) => Promise<{
-        data: Buffer;
+    transform: (inputBuffer: Uint8Array, transform: LocalImageTransform, imageConfig: ImageConfig<T>) => Promise<{
+        data: Uint8Array;
         format: ImageOutputFormat;
     }>;
+    /**
+     * A list of properties that should be used to generate the hash for the image.
+     *
+     * Generally, this should be all the properties that can change the result of the image. By default, this is `src`, `width`, `height`, `quality`, and `format`.
+     */
+    propertiesToHash?: string[];
 }
 export type BaseServiceTransform = {
     src: string;

package/dist/assets/services/service.js

@@ -1,6 +1,6 @@
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 import { isRemotePath, joinPaths } from "../../core/path.js";
-import { DEFAULT_OUTPUT_FORMAT, VALID_SUPPORTED_FORMATS } from "../consts.js";
+import { DEFAULT_HASH_PROPS, DEFAULT_OUTPUT_FORMAT, VALID_SUPPORTED_FORMATS } from "../consts.js";
 import { isESMImportedImage, isRemoteAllowed } from "../internal.js";
 function isLocalService(service) {
   if (!service) {
@@ -16,6 +16,7 @@ function parseQuality(quality) {
   return result;
 }
 const baseService = {
+  propertiesToHash: DEFAULT_HASH_PROPS,
   validateOptions(options) {
     if (!options.src || typeof options.src !== "string" && typeof options.src !== "object") {
       throw new AstroError({

package/dist/assets/services/vendor/squoosh/image-pool.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { ImageOutputFormat } from '../../../types.js';
 import type { Operation } from './image.js';
-export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: ImageOutputFormat, quality?: number): Promise<Uint8Array>;
+export declare function processBuffer(buffer: Uint8Array, operations: Operation[], encoding: ImageOutputFormat, quality?: number): Promise<Uint8Array>;

package/dist/assets/types.d.ts

@@ -5,15 +5,19 @@ export type ImageQualityPreset = 'low' | 'mid' | 'high' | 'max' | (string & {});
 export type ImageQuality = ImageQualityPreset | number;
 export type ImageInputFormat = (typeof VALID_INPUT_FORMATS)[number];
 export type ImageOutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
-export type AssetsGlobalStaticImagesList = Map<string, Map<string, {
-    finalPath: string;
-    transform: ImageTransform;
-}>>;
+export type AssetsGlobalStaticImagesList = Map<string, {
+    originalSrcPath: string;
+    transforms: Map<string, {
+        finalPath: string;
+        transform: ImageTransform;
+    }>;
+}>;
 declare global {
     var astroAsset: {
         imageService?: ImageService;
-        addStaticImage?: ((options: ImageTransform) => string) | undefined;
+        addStaticImage?: ((options: ImageTransform, hashProperties: string[]) => string) | undefined;
         staticImages?: AssetsGlobalStaticImagesList;
+        referencedImages?: Set<string>;
     };
 }
 /**

package/dist/assets/utils/emitAsset.js

@@ -19,6 +19,11 @@ async function emitESMImage(id, watchMode, fileEmitter) {
     src: "",
     ...fileMetadata
   };
+  Object.defineProperty(emittedImage, "fsPath", {
+    enumerable: false,
+    writable: false,
+    value: url
+  });
   if (!watchMode) {
     const pathname = decodeURI(url.pathname);
     const filename = path.basename(pathname, path.extname(pathname) + `.${fileMetadata.format}`);

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

@@ -1,3 +1,2 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { ImageMetadata } from '../types.js';
-export declare function imageMetadata(data: Buffer, src?: string): Promise<Omit<ImageMetadata, 'src'>>;
+export declare function imageMetadata(data: Uint8Array, src?: string): Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;

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

@@ -0,0 +1 @@
+export declare function getProxyCode(options: Record<string, any>, isSSR: boolean): string;

package/dist/assets/utils/proxy.js

@@ -0,0 +1,16 @@
+function getProxyCode(options, isSSR) {
+  return `
+						new Proxy(${JSON.stringify(options)}, {
+						get(target, name, receiver) {
+							if (name === 'clone') {
+								return structuredClone(target);
+							}
+							${!isSSR ? "globalThis.astroAsset.referencedImages.add(target.fsPath);" : ""}
+							return target[name];
+						}
+					})
+					`;
+}
+export {
+  getProxyCode
+};

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

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

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

@@ -1,3 +1,3 @@
 import type { ImageTransform } from '../types.js';
 export declare function propsToFilename(transform: ImageTransform, hash: string): string;
-export declare function hashTransform(transform: ImageTransform, imageService: string): string;
+export declare function hashTransform(transform: ImageTransform, imageService: string, propertiesToHash: string[]): string;

package/dist/assets/utils/transformToPath.js

@@ -12,9 +12,14 @@ function propsToFilename(transform, hash) {
   let outputExt = transform.format ? `.${transform.format}` : ext;
   return `/${filename}_${hash}${outputExt}`;
 }
-function hashTransform(transform, imageService) {
-  const { alt, class: className, style, widths, densities, ...rest } = transform;
-  const hashFields = { ...rest, imageService };
+function hashTransform(transform, imageService, propertiesToHash) {
+  const hashFields = propertiesToHash.reduce(
+    (acc, prop) => {
+      acc[prop] = transform[prop];
+      return acc;
+    },
+    { imageService }
+  );
   return shorthash(deterministicString(hashFields));
 }
 export {

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

@@ -12,6 +12,7 @@ import { isServerLikeOutput } from "../prerender/utils.js";
 import { VALID_INPUT_FORMATS, VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
 import { isESMImportedImage } from "./internal.js";
 import { emitESMImage } from "./utils/emitAsset.js";
+import { getProxyCode } from "./utils/proxy.js";
 import { hashTransform, propsToFilename } from "./utils/transformToPath.js";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
 const assetRegex = new RegExp(`\\.(${VALID_INPUT_FORMATS.join("|")})$`, "i");
@@ -20,7 +21,9 @@ function assets({
   mode
 }) {
   let resolvedConfig;
-  globalThis.astroAsset = {};
+  globalThis.astroAsset = {
+    referencedImages: /* @__PURE__ */ new Set()
+  };
   return [
     // Expose the components and different utilities from `astro:assets` and handle serving images from `/_image` in dev
     {
@@ -29,7 +32,7 @@ function assets({
         extendManualChunks(outputOptions, {
           after(id) {
             if (id.includes("astro/dist/assets/services/")) {
-              return `astro-assets-services`;
+              return `astro/assets-service`;
             }
           }
         });
@@ -64,15 +67,20 @@ function assets({
         if (mode != "build") {
           return;
         }
-        globalThis.astroAsset.addStaticImage = (options) => {
+        globalThis.astroAsset.addStaticImage = (options, hashProperties) => {
           if (!globalThis.astroAsset.staticImages) {
             globalThis.astroAsset.staticImages = /* @__PURE__ */ new Map();
           }
-          const originalImagePath = (isESMImportedImage(options.src) ? options.src.src : options.src).replace(settings.config.build.assetsPrefix || "", "");
-          const hash = hashTransform(options, settings.config.image.service.entrypoint);
+          const finalOriginalImagePath = (isESMImportedImage(options.src) ? options.src.src : options.src).replace(settings.config.build.assetsPrefix || "", "");
+          const originalSrcPath = isESMImportedImage(options.src) ? options.src.fsPath : options.src;
+          const hash = hashTransform(
+            options,
+            settings.config.image.service.entrypoint,
+            hashProperties
+          );
           let finalFilePath;
-          let transformsForPath = globalThis.astroAsset.staticImages.get(originalImagePath);
-          let transformForHash = transformsForPath?.get(hash);
+          let transformsForPath = globalThis.astroAsset.staticImages.get(finalOriginalImagePath);
+          let transformForHash = transformsForPath?.transforms.get(hash);
           if (transformsForPath && transformForHash) {
             finalFilePath = transformForHash.finalPath;
           } else {
@@ -80,10 +88,16 @@ function assets({
               joinPaths(settings.config.build.assets, propsToFilename(options, hash))
             );
             if (!transformsForPath) {
-              globalThis.astroAsset.staticImages.set(originalImagePath, /* @__PURE__ */ new Map());
-              transformsForPath = globalThis.astroAsset.staticImages.get(originalImagePath);
+              globalThis.astroAsset.staticImages.set(finalOriginalImagePath, {
+                originalSrcPath,
+                transforms: /* @__PURE__ */ new Map()
+              });
+              transformsForPath = globalThis.astroAsset.staticImages.get(finalOriginalImagePath);
             }
-            transformsForPath.set(hash, { finalPath: finalFilePath, transform: options });
+            transformsForPath.transforms.set(hash, {
+              finalPath: finalFilePath,
+              transform: options
+            });
           }
           if (settings.config.build.assetsPrefix) {
             return joinPaths(settings.config.build.assetsPrefix, finalFilePath);
@@ -122,7 +136,7 @@ function assets({
       configResolved(viteConfig) {
         resolvedConfig = viteConfig;
       },
-      async load(id) {
+      async load(id, options) {
         if (id !== removeQueryString(id)) {
           return;
         }
@@ -134,7 +148,14 @@ function assets({
               message: AstroErrorData.ImageNotFound.message(id)
             });
           }
-          return `export default ${JSON.stringify(meta)}`;
+          if (options?.ssr) {
+            return `export default ${getProxyCode(meta, isServerLikeOutput(settings.config))}`;
+          } else {
+            if (!globalThis.astroAsset.referencedImages)
+              globalThis.astroAsset.referencedImages = /* @__PURE__ */ new Set();
+            globalThis.astroAsset.referencedImages.add(meta.fsPath);
+            return `export default ${JSON.stringify(meta)}`;
+          }
         }
       }
     }

package/dist/cli/build/index.js

@@ -18,7 +18,7 @@ async function build({ flags }) {
     return;
   }
   const inlineConfig = flagsToAstroInlineConfig(flags);
-  await _build(inlineConfig);
+  await _build(inlineConfig, { force: flags.force ?? false });
 }
 export {
   build

package/dist/cli/info/index.js

@@ -35,11 +35,15 @@ async function copyToClipboard(text) {
   } else if (system === "win32") {
     command = "clip";
   } else {
-    const output = execSync("which xclip", { encoding: "utf8" });
-    if (output[0] !== "/") {
+    try {
+      const output = execSync("which xclip", { encoding: "utf8" });
+      if (output[0] !== "/") {
+        return;
+      }
+      command = "xclip -sel clipboard -l 1";
+    } catch (e) {
       return;
     }
-    command = "xclip -sel clipboard -l 1";
   }
   console.log();
   const { shouldCopy } = await prompts({

package/dist/content/consts.d.ts

@@ -3,6 +3,7 @@ export declare const CONTENT_RENDER_FLAG = "astroRenderContent";
 export declare const CONTENT_FLAG = "astroContentCollectionEntry";
 export declare const DATA_FLAG = "astroDataCollectionEntry";
 export declare const VIRTUAL_MODULE_ID = "astro:content";
+export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
 export declare const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 export declare const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 export declare const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";

package/dist/content/consts.js

@@ -3,6 +3,7 @@ const CONTENT_RENDER_FLAG = "astroRenderContent";
 const CONTENT_FLAG = "astroContentCollectionEntry";
 const DATA_FLAG = "astroDataCollectionEntry";
 const VIRTUAL_MODULE_ID = "astro:content";
+const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
 const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
@@ -21,6 +22,7 @@ export {
   DATA_FLAG,
   LINKS_PLACEHOLDER,
   PROPAGATED_ASSET_FLAG,
+  RESOLVED_VIRTUAL_MODULE_ID,
   SCRIPTS_PLACEHOLDER,
   STYLES_PLACEHOLDER,
   VIRTUAL_MODULE_ID

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

@@ -1,3 +1,11 @@
 import type { PluginContext } from 'rollup';
 import { z } from 'zod';
-export declare function createImage(pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, import("../assets/types.js").ImageMetadata | z.ZodNever, string>;
+export declare function createImage(pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, z.ZodNever | {
+    ASTRO_ASSET: boolean;
+    src: string;
+    width: number;
+    height: number;
+    format: "jpeg" | "jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "avif";
+    orientation?: number | undefined;
+    fsPath: string;
+}, string>;

package/dist/content/runtime-assets.js

@@ -17,7 +17,7 @@ function createImage(pluginContext, entryFilePath) {
         });
         return z.never();
       }
-      return metadata;
+      return { ...metadata, ASTRO_ASSET: true };
     });
   };
 }

package/dist/content/runtime.d.ts

@@ -5,6 +5,7 @@ type LazyImport = () => Promise<any>;
 type GlobResult = Record<string, LazyImport>;
 type CollectionToEntryMap = Record<string, GlobResult>;
 type GetEntryImport = (collection: string, lookupId: string) => Promise<LazyImport>;
+export declare function defineCollection(config: any): any;
 export declare function createCollectionToGlobResultMap({ globResult, contentDir, }: {
     globResult: GlobResult;
     contentDir: string;

package/dist/content/runtime.js

@@ -10,6 +10,11 @@ import {
   renderUniqueStylesheet,
   unescapeHTML
 } from "../runtime/server/index.js";
+function defineCollection(config) {
+  if (!config.type)
+    config.type = "content";
+  return config;
+}
 function createCollectionToGlobResultMap({
   globResult,
   contentDir
@@ -48,7 +53,7 @@ function createGetCollection({
       type === "content" ? contentCollectionToEntryMap[collection] : dataCollectionToEntryMap[collection]
     );
     let entries = [];
-    if (import.meta.env.PROD && cacheEntriesByCollection.has(collection)) {
+    if (!import.meta.env?.DEV && cacheEntriesByCollection.has(collection)) {
       entries = [...cacheEntriesByCollection.get(collection)];
     } else {
       entries = await Promise.all(
@@ -291,5 +296,6 @@ export {
   createGetEntries,
   createGetEntry,
   createGetEntryBySlug,
-  createReference
+  createReference,
+  defineCollection
 };

package/dist/content/utils.d.ts

@@ -126,6 +126,7 @@ export declare function parseFrontmatter(fileContents: string): matter.GrayMatte
  * subscribe to changes during dev server updates.
  */
 export declare const globalContentConfigObserver: ContentObservable;
+export declare function hasAnyContentFlag(viteId: string): boolean;
 export declare function hasContentFlag(viteId: string, flag: (typeof CONTENT_FLAGS)[number]): boolean;
 export declare function loadContentConfig({ fs, settings, viteServer, }: {
     fs: typeof fsMod;

package/dist/content/utils.js

@@ -219,6 +219,14 @@ function parseFrontmatter(fileContents) {
   }
 }
 const globalContentConfigObserver = contentObservable({ status: "init" });
+function hasAnyContentFlag(viteId) {
+  const flags = new URLSearchParams(viteId.split("?")[1] ?? "");
+  const flag = Array.from(flags.keys()).at(0);
+  if (typeof flag !== "string") {
+    return false;
+  }
+  return CONTENT_FLAGS.includes(flag);
+}
 function hasContentFlag(viteId, flag) {
   const flags = new URLSearchParams(viteId.split("?")[1] ?? "");
   return flags.has(flag);
@@ -349,6 +357,7 @@ export {
   getEntryType,
   getExtGlob,
   globalContentConfigObserver,
+  hasAnyContentFlag,
   hasContentFlag,
   hasUnderscoreBelowContentDirectoryPath,
   loadContentConfig,

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

@@ -85,14 +85,14 @@ function astroContentAssetPropagationPlugin({
 function astroConfigBuildPlugin(options, internals) {
   let ssrPluginContext = void 0;
   return {
-    build: "ssr",
+    targets: ["server"],
     hooks: {
-      "build:before": ({ build }) => {
+      "build:before": ({ target }) => {
         return {
           vitePlugin: {
             name: "astro:content-build-plugin",
             generateBundle() {
-              if (build === "ssr") {
+              if (target === "server") {
                 ssrPluginContext = this;
               }
             }
@@ -113,26 +113,46 @@ function astroConfigBuildPlugin(options, internals) {
             let entryStyles = /* @__PURE__ */ new Set();
             let entryLinks = /* @__PURE__ */ new Set();
             let entryScripts = /* @__PURE__ */ new Set();
-            for (const id of Object.keys(chunk.modules)) {
-              for (const [pageInfo] of walkParentInfos(id, ssrPluginContext)) {
-                if (moduleIsTopLevelPage(pageInfo)) {
-                  const pageViteID = pageInfo.id;
-                  const pageData = getPageDataByViteID(internals, pageViteID);
-                  if (!pageData)
-                    continue;
-                  const _entryCss = pageData.propagatedStyles?.get(id);
-                  const _entryScripts = pageData.propagatedScripts?.get(id);
-                  if (_entryCss) {
-                    for (const value of _entryCss) {
-                      if (value.type === "inline")
-                        entryStyles.add(value.content);
-                      if (value.type === "external")
-                        entryLinks.add(value.src);
-                    }
+            if (options.settings.config.experimental.contentCollectionCache) {
+              for (const id of chunk.moduleIds) {
+                const _entryCss = internals.propagatedStylesMap.get(id);
+                const _entryScripts = internals.propagatedScriptsMap.get(id);
+                if (_entryCss) {
+                  for (const value of _entryCss) {
+                    if (value.type === "inline")
+                      entryStyles.add(value.content);
+                    if (value.type === "external")
+                      entryLinks.add(value.src);
+                  }
+                }
+                if (_entryScripts) {
+                  for (const value of _entryScripts) {
+                    entryScripts.add(value);
                   }
-                  if (_entryScripts) {
-                    for (const value of _entryScripts) {
-                      entryScripts.add(value);
+                }
+              }
+            } else {
+              for (const id of Object.keys(chunk.modules)) {
+                for (const [pageInfo] of walkParentInfos(id, ssrPluginContext)) {
+                  if (moduleIsTopLevelPage(pageInfo)) {
+                    const pageViteID = pageInfo.id;
+                    const pageData = getPageDataByViteID(internals, pageViteID);
+                    if (!pageData)
+                      continue;
+                    const _entryCss = internals.propagatedStylesMap?.get(id);
+                    const _entryScripts = pageData.propagatedScripts?.get(id);
+                    if (_entryCss) {
+                      for (const value of _entryCss) {
+                        if (value.type === "inline")
+                          entryStyles.add(value.content);
+                        if (value.type === "external")
+                          entryLinks.add(value.src);
+                      }
+                    }
+                    if (_entryScripts) {
+                      for (const value of _entryScripts) {
+                        entryScripts.add(value);
+                      }
                     }
                   }
                 }
@@ -144,12 +164,16 @@ function astroConfigBuildPlugin(options, internals) {
                 JSON.stringify(STYLES_PLACEHOLDER),
                 JSON.stringify(Array.from(entryStyles))
               );
+            } else {
+              newCode = newCode.replace(JSON.stringify(STYLES_PLACEHOLDER), "[]");
             }
             if (entryLinks.size) {
               newCode = newCode.replace(
                 JSON.stringify(LINKS_PLACEHOLDER),
                 JSON.stringify(Array.from(entryLinks).map(prependBase))
               );
+            } else {
+              newCode = newCode.replace(JSON.stringify(LINKS_PLACEHOLDER), "[]");
             }
             if (entryScripts.size) {
               const entryFileNames = /* @__PURE__ */ new Set();
@@ -176,8 +200,10 @@ function astroConfigBuildPlugin(options, internals) {
                   }))
                 )
               );
+            } else {
+              newCode = newCode.replace(JSON.stringify(SCRIPTS_PLACEHOLDER), "[]");
             }
-            mutate(chunk, "server", newCode);
+            mutate(chunk, ["server"], newCode);
           }
         }
       }

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

@@ -1,8 +1,10 @@
 import * as devalue from "devalue";
 import { extname } from "node:path";
 import { pathToFileURL } from "node:url";
+import { getProxyCode } from "../assets/utils/proxy.js";
 import { AstroError } from "../core/errors/errors.js";
 import { AstroErrorData } from "../core/errors/index.js";
+import { isServerLikeOutput } from "../prerender/utils.js";
 import { escapeViteEnvReferences } from "../vite-plugin-utils/index.js";
 import { CONTENT_FLAG, DATA_FLAG } from "./consts.js";
 import {
@@ -60,7 +62,7 @@ function astroContentImportPlugin({
           const code = escapeViteEnvReferences(`
 export const id = ${JSON.stringify(id)};
 export const collection = ${JSON.stringify(collection)};
-export const data = ${stringifyEntryData(data)};
+export const data = ${stringifyEntryData(data, isServerLikeOutput(settings.config))};
 export const _internal = {
 	type: 'data',
 	filePath: ${JSON.stringify(_internal.filePath)},
@@ -83,7 +85,7 @@ export const _internal = {
 						export const collection = ${JSON.stringify(collection)};
 						export const slug = ${JSON.stringify(slug)};
 						export const body = ${JSON.stringify(body)};
-						export const data = ${stringifyEntryData(data)};
+						export const data = ${stringifyEntryData(data, isServerLikeOutput(settings.config))};
 						export const _internal = {
 							type: 'content',
 							filePath: ${JSON.stringify(_internal.filePath)},
@@ -259,12 +261,16 @@ async function getContentConfigFromGlobal() {
   }
   return contentConfig;
 }
-function stringifyEntryData(data) {
+function stringifyEntryData(data, isSSR) {
   try {
     return devalue.uneval(data, (value) => {
       if (value instanceof URL) {
         return `new URL(${JSON.stringify(value.href)})`;
       }
+      if (typeof value === "object" && "ASTRO_ASSET" in value) {
+        const { ASTRO_ASSET, ...asset } = value;
+        return getProxyCode(asset, isSSR);
+      }
     });
   } catch (e) {
     if (e instanceof Error) {