astro 7.1.6 → 7.2.1

package/dist/cli/preview/index.js

@@ -1,14 +1,25 @@
 import colors from "piccolore";
+import { pathToFileURL } from "node:url";
+import { checkExistingServer, removeLockFile, writeLockFile } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
 import { printHelp } from "../../core/messages/runtime.js";
 import previewServer from "../../core/preview/index.js";
-import { flagsToAstroInlineConfig } from "../flags.js";
+import { isRunByAgent } from "../agent.js";
+import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
+import { background, logs, previewServerCommand, status, stop } from "../server.js";
 async function preview({ flags }) {
   if (flags?.help || flags?.h) {
     printHelp({
       commandName: "astro preview",
-      usage: "[...flags]",
+      usage: "[command] [...flags]",
       tables: {
+        Commands: [
+          ["stop", "Stop a running background preview server."],
+          ["status", "Check if a preview server is running."],
+          ["logs [--follow]", "View logs from a background preview server."]
+        ],
         Flags: [
+          ["--background", "Start the preview server as a background process."],
           ["--port", `Specify which port to run on. Defaults to 4321.`],
           ["--host", `Listen on all addresses, including LAN and public addresses.`],
           ["--host <custom-address>", `Expose on a network IP address at <custom-address>`],
@@ -26,8 +37,71 @@ async function preview({ flags }) {
     });
     return;
   }
+  const agentDetected = !process.env.ASTRO_PREVIEW_BACKGROUND && isRunByAgent();
+  if (agentDetected) {
+    flags.json = true;
+  }
+  const logger = createLoggerFromFlags(flags);
+  const subcommand = flags._[3]?.toString();
+  if (subcommand === "stop") {
+    await stop({ flags, logger, config: previewServerCommand });
+    return;
+  }
+  if (subcommand === "status") {
+    await status({ flags, logger, config: previewServerCommand });
+    return;
+  }
+  if (subcommand === "logs") {
+    await logs({ flags, logger, config: previewServerCommand });
+    return;
+  }
+  if (flags.background || agentDetected) {
+    await background({ flags, logger, config: previewServerCommand });
+    return;
+  }
+  if (subcommand) {
+    logger.error(
+      "SKIP_FORMAT",
+      `Unknown command: astro preview ${subcommand}
+
+Run \`astro preview --help\` to see available commands.`
+    );
+    process.exit(1);
+  }
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existingServer = checkExistingServer(root, "preview");
+  if (existingServer) {
+    const message = [
+      "Another astro preview server is already running.",
+      "",
+      `  URL:  ${existingServer.url}`,
+      `  PID:  ${existingServer.pid}`,
+      "",
+      `Run \`astro preview stop\` to stop it, or use \`astro preview --force\` to replace it.`
+    ].join("\n");
+    throw new Error(message);
+  }
   const inlineConfig = flagsToAstroInlineConfig(flags);
-  return await previewServer(inlineConfig);
+  const server = await previewServer(inlineConfig);
+  const serverUrl = server.urls?.local[0] ? new URL(server.urls.local[0]).origin : `http://${server.host ?? "localhost"}:${server.port}`;
+  writeLockFile(
+    root,
+    {
+      pid: process.pid,
+      port: server.port,
+      url: serverUrl,
+      urls: server.urls,
+      background: !!process.env.ASTRO_PREVIEW_BACKGROUND,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    "preview"
+  );
+  const originalStop = server.stop.bind(server);
+  server.stop = async () => {
+    removeLockFile(root, "preview");
+    await originalStop();
+  };
+  return server;
 }
 export {
   preview

package/dist/cli/server.d.ts

@@ -0,0 +1,60 @@
+import { type LockFileData, type ServerCommand } from '../core/dev/lockfile.js';
+import type { AstroLogger } from '../core/logger/core.js';
+import type { Flags } from './flags.js';
+export interface BackgroundCommandConfig {
+    command: ServerCommand;
+    displayName: string;
+    envVar: 'ASTRO_DEV_BACKGROUND' | 'ASTRO_PREVIEW_BACKGROUND';
+}
+export declare const devServerCommand: BackgroundCommandConfig;
+export declare const previewServerCommand: BackgroundCommandConfig;
+export interface BackgroundResult {
+    pid: number;
+    url: string;
+    existing?: boolean;
+}
+export interface BackgroundErrorResult {
+    error: string;
+    message: string;
+}
+export interface StopResult {
+    stopped: boolean;
+    pid?: number;
+    reason?: string;
+}
+export interface StatusResult {
+    running: boolean;
+    pid?: number;
+    url?: string;
+    port?: number;
+    background?: boolean;
+    uptime?: number;
+}
+export declare function formatBackgroundOutput(result: BackgroundResult | BackgroundErrorResult): string;
+export declare function formatStopOutput(result: StopResult): string;
+export declare function formatStatusOutput(result: StatusResult): string;
+export declare function formatServerRunningMessage(data: LockFileData, config: BackgroundCommandConfig, { existing }?: {
+    existing?: boolean;
+}): string;
+export declare function buildBackgroundArgs(command: ServerCommand, flags: Flags): string[];
+export declare function stopExistingServer(root: URL, command: ServerCommand, pid: number): Promise<void>;
+export declare function background({ flags, logger, config, }: {
+    flags: Flags;
+    logger: AstroLogger;
+    config: BackgroundCommandConfig;
+}): Promise<void>;
+export declare function stop({ flags, logger, config, }: {
+    flags: Flags;
+    logger: AstroLogger;
+    config: BackgroundCommandConfig;
+}): Promise<void>;
+export declare function status({ flags, logger, config, }: {
+    flags: Flags;
+    logger: AstroLogger;
+    config: BackgroundCommandConfig;
+}): Promise<void>;
+export declare function logs({ flags, logger, config, }: {
+    flags: Flags;
+    logger: AstroLogger;
+    config: BackgroundCommandConfig;
+}): Promise<void>;

package/dist/cli/server.js

@@ -0,0 +1,274 @@
+import { spawn } from "node:child_process";
+import {
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  statSync,
+  watch
+} from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolveRoot } from "../core/config/config.js";
+import {
+  GRACEFUL_SHUTDOWN_TIMEOUT,
+  checkExistingServer,
+  getLogFileURL,
+  isProcessAlive,
+  readLockFile,
+  removeLockFile
+} from "../core/dev/lockfile.js";
+const require2 = createRequire(import.meta.url);
+const devServerCommand = {
+  command: "dev",
+  displayName: "Dev server",
+  envVar: "ASTRO_DEV_BACKGROUND"
+};
+const previewServerCommand = {
+  command: "preview",
+  displayName: "Preview server",
+  envVar: "ASTRO_PREVIEW_BACKGROUND"
+};
+function formatBackgroundOutput(result) {
+  return JSON.stringify(result);
+}
+function formatStopOutput(result) {
+  return JSON.stringify(result);
+}
+function formatStatusOutput(result) {
+  return JSON.stringify(result);
+}
+function formatServerRunningMessage(data, config, { existing = false } = {}) {
+  const command = `astro ${config.command}`;
+  const lines = [
+    `${config.displayName} ${existing ? "already running" : "running"} at ${data.url} (pid ${data.pid})`
+  ];
+  if (data.urls && data.urls.network.length > 0) {
+    lines.push("  Network:");
+    for (const url of data.urls.network) {
+      lines.push(`    ${url}`);
+    }
+  }
+  lines.push(
+    `  Stop:   ${command} stop`,
+    `  Status: ${command} status`,
+    `  Logs:   ${command} logs`
+  );
+  return lines.join("\n");
+}
+function getRootURL(flags) {
+  return pathToFileURL(resolveRoot(flags.root) + "/");
+}
+function buildBackgroundArgs(command, flags) {
+  const args = [command];
+  if (flags.port) args.push("--port", String(flags.port));
+  if (flags.host != null) {
+    if (typeof flags.host === "string") {
+      args.push("--host", flags.host);
+    } else {
+      args.push("--host");
+    }
+  }
+  if (flags.config) args.push("--config", String(flags.config));
+  if (flags.root) args.push("--root", String(flags.root));
+  if (flags.allowedHosts) args.push("--allowed-hosts", String(flags.allowedHosts));
+  if (flags.json) args.push("--json");
+  return args;
+}
+async function stopExistingServer(root, command, pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + GRACEFUL_SHUTDOWN_TIMEOUT;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) break;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (isProcessAlive(pid)) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  removeLockFile(root, command);
+}
+async function background({
+  flags,
+  logger,
+  config
+}) {
+  const root = getRootURL(flags);
+  const existing = checkExistingServer(root, config.command);
+  if (existing && !flags.force) {
+    logger.info("SKIP_FORMAT", formatServerRunningMessage(existing, config, { existing: true }));
+    return;
+  }
+  if (existing && flags.force) {
+    await stopExistingServer(root, config.command, existing.pid);
+  }
+  const args = buildBackgroundArgs(config.command, flags);
+  const logFileURL = getLogFileURL(root, config.command);
+  const logFilePath = fileURLToPath(logFileURL);
+  const dotAstroDir = fileURLToPath(new URL(".astro/", root));
+  if (!existsSync(dotAstroDir)) {
+    mkdirSync(dotAstroDir, { recursive: true });
+  }
+  const logFd = openSync(logFilePath, "w");
+  const rootPath = fileURLToPath(root);
+  const astroBin = resolve(dirname(require2.resolve("astro/package.json")), "bin", "astro.mjs");
+  const child = spawn(process.execPath, [astroBin, ...args], {
+    detached: true,
+    windowsHide: true,
+    stdio: ["ignore", logFd, logFd],
+    cwd: rootPath,
+    env: { ...process.env, [config.envVar]: "1" }
+  });
+  child.unref();
+  const childPid = child.pid;
+  if (!childPid) {
+    logger.error("SKIP_FORMAT", `Failed to spawn background ${config.command} server process.`);
+    process.exit(1);
+  }
+  const timeout = 3e4;
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(childPid)) {
+      logger.error("SKIP_FORMAT", `${config.displayName} process exited before becoming ready.`);
+      process.exit(1);
+    }
+    const lockData = readLockFile(root, config.command);
+    if (lockData && lockData.pid === childPid) {
+      logger.info("SKIP_FORMAT", formatServerRunningMessage(lockData, config));
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  try {
+    process.kill(childPid, "SIGTERM");
+  } catch {
+  }
+  removeLockFile(root, config.command);
+  logger.error("SKIP_FORMAT", `${config.displayName} failed to start within ${timeout / 1e3}s.`);
+  process.exit(1);
+}
+async function stop({
+  flags,
+  logger,
+  config
+}) {
+  const root = getRootURL(flags);
+  const existing = checkExistingServer(root, config.command);
+  if (!existing) {
+    logger.info("SKIP_FORMAT", `No ${config.command} server is running.`);
+    return;
+  }
+  await stopExistingServer(root, config.command, existing.pid);
+  logger.info("SKIP_FORMAT", `Stopped ${config.command} server (pid ${existing.pid}).`);
+}
+async function status({
+  flags,
+  logger,
+  config
+}) {
+  const root = getRootURL(flags);
+  const existing = checkExistingServer(root, config.command);
+  if (!existing) {
+    logger.info("SKIP_FORMAT", `No ${config.command} server is running.`);
+    return;
+  }
+  const startedAt = new Date(existing.startedAt).getTime();
+  const uptime = Math.floor((Date.now() - startedAt) / 1e3);
+  const lines = [
+    `${config.displayName} running at ${existing.url} (pid ${existing.pid}, uptime ${uptime}s${existing.background ? ", background" : ""})`
+  ];
+  if (existing.urls && existing.urls.network.length > 0) {
+    lines.push("  Network:");
+    for (const url of existing.urls.network) {
+      lines.push(`    ${url}`);
+    }
+  }
+  logger.info("SKIP_FORMAT", lines.join("\n"));
+}
+async function logs({
+  flags,
+  logger,
+  config
+}) {
+  const root = getRootURL(flags);
+  const existing = checkExistingServer(root, config.command);
+  if (!existing) {
+    logger.error("SKIP_FORMAT", `No ${config.command} server is running.`);
+    process.exit(1);
+  }
+  if (!existing.background) {
+    logger.error(
+      "SKIP_FORMAT",
+      `The running ${config.command} server was not started with \`astro ${config.command} --background\`. View logs in the terminal where it was started.`
+    );
+    process.exit(1);
+  }
+  const logFileURL = getLogFileURL(root, config.command);
+  const logFilePath = fileURLToPath(logFileURL);
+  if (!existsSync(logFilePath)) {
+    logger.error("SKIP_FORMAT", "No log file found.");
+    process.exit(1);
+  }
+  const follow = flags.follow || flags.f;
+  if (!follow) {
+    const content = readFileSync(logFilePath, "utf-8");
+    process.stdout.write(content);
+    return;
+  }
+  let offset = statSync(logFilePath).size;
+  if (offset > 0) {
+    const content = readFileSync(logFilePath, "utf-8");
+    process.stdout.write(content);
+  }
+  const watcher = watch(logFilePath, () => {
+    const currentSize = statSync(logFilePath).size;
+    if (currentSize > offset) {
+      const stream = createReadStream(logFilePath, { start: offset, encoding: "utf-8" });
+      stream.on("data", (chunk) => process.stdout.write(chunk));
+      stream.on("end", () => {
+        offset = currentSize;
+      });
+    }
+  });
+  const aliveCheck = setInterval(() => {
+    if (!isProcessAlive(existing.pid)) {
+      const currentSize = statSync(logFilePath).size;
+      if (currentSize > offset) {
+        const remaining = readFileSync(logFilePath, { encoding: "utf-8" }).slice(offset);
+        process.stdout.write(remaining);
+      }
+      watcher.close();
+      clearInterval(aliveCheck);
+    }
+  }, 1e3);
+  const cleanup = () => {
+    watcher.close();
+    clearInterval(aliveCheck);
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  await new Promise(() => {
+  });
+}
+export {
+  background,
+  buildBackgroundArgs,
+  devServerCommand,
+  formatBackgroundOutput,
+  formatServerRunningMessage,
+  formatStatusOutput,
+  formatStopOutput,
+  logs,
+  previewServerCommand,
+  status,
+  stop,
+  stopExistingServer
+};

package/dist/content/content-layer.js

@@ -196,7 +196,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.1.6") {
+    if (previousAstroVersion && previousAstroVersion !== "7.2.1") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -204,8 +204,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("7.1.6") {
-      this.#store.metaStore().set("astro-version", "7.1.6");
+    if ("7.2.1") {
+      this.#store.metaStore().set("astro-version", "7.2.1");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);
@@ -265,6 +265,7 @@ ${contentConfig.error.message}`
         }
       })
     );
+    this.#validateReferences(contentConfig.config.collections, logger);
     await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });
     await fs.mkdir(this.#settings.dotAstroDir, { recursive: true });
     const assetImportsFile = new URL(ASSET_IMPORTS_FILE, this.#settings.dotAstroDir);
@@ -277,6 +278,65 @@ ${contentConfig.error.message}`
       await this.regenerateCollectionFileManifest();
     }
   }
+  /**
+   * After all loaders complete, walks every entry's data to find reference objects
+   * (`{ id, collection }`) and checks that the referenced entry exists in the store.
+   * This replaces the inline Zod validation that was removed in the Zod 4 upgrade.
+   */
+  #validateReferences(collections, logger) {
+    const collectionNames = new Set(Object.keys(collections));
+    for (const collectionName of collectionNames) {
+      for (const entry of this.#store.values(collectionName)) {
+        if (entry?.data) {
+          this.#findInvalidReferences(
+            entry.data,
+            collectionNames,
+            collectionName,
+            entry.id,
+            logger,
+            ""
+          );
+        }
+      }
+    }
+  }
+  #findInvalidReferences(value, collectionNames, ownerCollection, ownerId, logger, path) {
+    if (value == null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        this.#findInvalidReferences(
+          value[i],
+          collectionNames,
+          ownerCollection,
+          ownerId,
+          logger,
+          `${path}[${i}]`
+        );
+      }
+      return;
+    }
+    const obj = value;
+    if (typeof obj.collection === "string" && collectionNames.has(obj.collection)) {
+      const refId = typeof obj.id === "string" ? obj.id : typeof obj.slug === "string" ? obj.slug : void 0;
+      if (refId !== void 0 && !this.#store.has(obj.collection, refId)) {
+        const fieldPath = path ? ` (field: ${path})` : "";
+        logger.error(
+          `Invalid content reference: entry "${ownerId}" in collection "${ownerCollection}"${fieldPath} references "${refId}" in collection "${obj.collection}", but that entry does not exist.`
+        );
+      }
+      return;
+    }
+    for (const [key, val] of Object.entries(obj)) {
+      this.#findInvalidReferences(
+        val,
+        collectionNames,
+        ownerCollection,
+        ownerId,
+        logger,
+        path ? `${path}.${key}` : key
+      );
+    }
+  }
   async regenerateCollectionFileManifest() {
     const collectionsManifest = new URL(COLLECTIONS_MANIFEST_FILE, this.#settings.dotAstroDir);
     this.#logger.debug("content", "Regenerating collection file manifest");

package/dist/content/loaders/file.js

@@ -1,6 +1,6 @@
 import { existsSync, promises as fs } from "node:fs";
 import { fileURLToPath } from "node:url";
-import yaml from "js-yaml";
+import * as yaml from "js-yaml";
 import * as toml from "smol-toml";
 import { FileGlobNotSupported, FileParserNotFound } from "../../core/errors/errors-data.js";
 import { AstroError } from "../../core/errors/index.js";

package/dist/content/loaders/glob.js

@@ -8,7 +8,7 @@ import { glob as tinyglobby } from "tinyglobby";
 import { getContentEntryIdAndSlug, posixRelative } from "../utils.js";
 function generateIdDefault({ entry, base, data }, isLegacy) {
   if (data.slug) {
-    return data.slug;
+    return String(data.slug);
   }
   const entryURL = new URL(encodeURI(entry), base);
   if (isLegacy) {
@@ -45,7 +45,8 @@ function glob(globOptions) {
     );
   }
   const isLegacy = !!globOptions[secretLegacyFlag];
-  const generateId = globOptions?.generateId ?? ((opts) => generateIdDefault(opts, isLegacy));
+  const userGenerateId = globOptions?.generateId ?? ((opts) => generateIdDefault(opts, isLegacy));
+  const generateId = (opts) => String(userGenerateId(opts));
   const fileToIdMap = /* @__PURE__ */ new Map();
   return {
     name: "glob-loader",

package/dist/content/mutable-data-store.js

@@ -2,7 +2,7 @@ import { existsSync, promises as fs } from "node:fs";
 import { fileURLToPath } from "node:url";
 import * as devalue from "devalue";
 import { forEach } from "neotraverse";
-import { imageSrcToImportId, importIdToSymbolName } from "../assets/utils/resolveImports.js";
+import { imageSrcToImportId } from "../assets/utils/resolveImports.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { DATA_STORE_MANIFEST_FILE, IMAGE_IMPORT_PREFIX } from "./consts.js";
 import {
@@ -109,8 +109,8 @@ class MutableDataStore extends ImmutableDataStore {
     const imports = [];
     const exports = [];
     const sortedAssetImports = [...this.#assetImports].sort();
-    sortedAssetImports.forEach((id) => {
-      const symbol = importIdToSymbolName(id);
+    sortedAssetImports.forEach((id, index) => {
+      const symbol = `__ASTRO_IMAGE_IMPORT_${index}`;
       imports.push(`import ${symbol} from ${JSON.stringify(id)};`);
       exports.push(`[${JSON.stringify(id)}, ${symbol}]`);
     });

package/dist/content/runtime.d.ts

@@ -33,12 +33,14 @@ type ContentEntryResult = {
     body: string;
     collection: string;
     data: Record<string, any>;
+    digest?: string | number;
     render(): Promise<RenderResult>;
 };
 type DataEntryResult = {
     id: string;
     collection: string;
     data: Record<string, any>;
+    digest?: string | number;
 };
 type EntryLookupObject = {
     collection: string;
@@ -69,6 +71,7 @@ type RenderResult = {
     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 resolveEntryData<T extends Record<string, unknown>>(entry: DataEntry<T>, 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.ZodPipe<z.ZodNumber, z.ZodTransform<string, number>>, z.ZodString, z.ZodObject<{
     id: z.ZodString;

package/dist/content/runtime.js

@@ -3,6 +3,7 @@ import { forEach } from "neotraverse";
 import * as z from "zod/v4";
 import { createSvgComponent } from "../assets/runtime.js";
 import { imageSrcToImportId } from "../assets/utils/resolveImports.js";
+import { recordContentEntryRender } from "../core/build/incremental-content-collector.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { isRemotePath, prependForwardSlash } from "../core/path.js";
 import {
@@ -77,7 +78,7 @@ function createGetCollection({
       const { default: imageAssetMap } = await import("astro:asset-imports");
       const result = [];
       for (const rawEntry of await store.values(collection)) {
-        const data = updateImageReferencesInData(rawEntry.data, rawEntry.filePath, imageAssetMap);
+        const data = resolveEntryData(rawEntry, imageAssetMap);
         let entry = {
           ...rawEntry,
           data,
@@ -134,7 +135,7 @@ function createGetEntry({ liveCollections }) {
         return;
       }
       const { default: imageAssetMap } = await import("astro:asset-imports");
-      const data = updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap);
+      const data = resolveEntryData(entry, imageAssetMap);
       const result = {
         ...entry,
         data,
@@ -381,10 +382,14 @@ function updateImageReferencesInData(data, fileName, imageAssetMap) {
   });
   return copy;
 }
+function resolveEntryData(entry, imageAssetMap) {
+  return entry.assetImports?.length ? updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap) : structuredClone(entry.data);
+}
 async function renderEntry(entry) {
   if (!entry) {
     throw new AstroError(AstroErrorData.RenderUndefinedEntryError);
   }
+  recordContentEntryRender(entry.filePath);
   if (entry.deferredRender) {
     try {
       const { default: contentModules } = await import("astro:content-module-imports");
@@ -561,5 +566,6 @@ export {
   defineCollection,
   defineLiveCollection,
   renderEntry,
+  resolveEntryData,
   updateImageReferencesInData
 };

package/dist/content/types-generator.js

@@ -373,6 +373,7 @@ async function writeContentFiles({
   data: ${dataType};
   rendered?: RenderedContent;
   filePath?: string;
+  digest?: string | number;
 }>;
 `;
     if (collectionConfig && (collectionConfig.schema || await getContentLayerSchema(collectionConfig, collectionKey))) {

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

@@ -1,5 +1,6 @@
 import { extname } from "node:path";
 import { getAssetsPrefix } from "../assets/utils/getAssetsPrefix.js";
+import { createContentDataIncrementalMetadata } from "../core/build/incremental-metadata.js";
 import { fileExtension } from "../core/path.js";
 import { fileURLToPath } from "node:url";
 import { isRunnableDevEnvironment } from "vite";
@@ -107,7 +108,11 @@ function astroContentAssetPropagationPlugin({
 					const defaultMod = { __astroPropagation: true, getMod, collectedLinks, collectedStyles, collectedScripts: [] };
 					export default defaultMod;
 				`;
-          return { code, map: { mappings: "" } };
+          return {
+            code,
+            map: { mappings: "" },
+            meta: createContentDataIncrementalMetadata()
+          };
         }
       }
     }