astro 7.1.6 → 7.2.0

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.0") {
       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.0") {
+      this.#store.metaStore().set("astro-version", "7.2.0");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

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;

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 {
@@ -385,6 +386,7 @@ 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");

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()
+          };
         }
       }
     }

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

@@ -2,6 +2,8 @@ import { extname } from "node:path";
 import { pathToFileURL } from "node:url";
 import * as devalue from "devalue";
 import { getProxyCode } from "../assets/utils/proxy.js";
+import { createContentDataIncrementalMetadata } from "../core/build/incremental-metadata.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { AstroError } from "../core/errors/errors.js";
 import { AstroErrorData } from "../core/errors/index.js";
 import { CONTENT_FLAG, DATA_FLAG } from "./consts.js";
@@ -22,7 +24,6 @@ import {
   reloadContentConfigObserver,
   reverseSymlink
 } from "./utils.js";
-import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 function getContentRendererByViteId(viteId, settings) {
   let ext = viteId.split(".").pop();
   if (!ext) return void 0;
@@ -91,7 +92,11 @@ export const _internal = {
 	rawData: ${JSON.stringify(_internal.rawData)},
 };
 `;
-            return code;
+            return {
+              code,
+              map: { mappings: "" },
+              meta: createContentDataIncrementalMetadata()
+            };
           } else if (hasContentFlag(viteId, CONTENT_FLAG)) {
             const fileId = reverseSymlink({ entry: viteId.split("?")[0], contentDir, symlinks });
             const { id, slug, collection, body, data, _internal } = await getContentEntryModule({
@@ -114,7 +119,11 @@ export const _internal = {
 							filePath: ${JSON.stringify(_internal.filePath)},
 							rawData: ${JSON.stringify(_internal.rawData)},
 						};`;
-            return { code, map: { mappings: "" } };
+            return {
+              code,
+              map: { mappings: "" },
+              meta: createContentDataIncrementalMetadata()
+            };
           }
         }
       },

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -1,7 +1,7 @@
 import nodeFs from "node:fs";
 import { fileURLToPath } from "node:url";
-import { dataToEsm } from "@rollup/pluginutils";
 import { isRunnableDevEnvironment, normalizePath } from "vite";
+import { createContentDataIncrementalMetadata } from "../core/build/incremental-metadata.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/viteUtils.js";
@@ -28,7 +28,6 @@ import {
 } from "./consts.js";
 import { getDataStoreChunkSize, getDataStoreDir, getDataStoreFile } from "./paths.js";
 import { getContentPaths, isDeferredModule } from "./utils.js";
-const LARGE_DATA_STORE_THRESHOLD = 5 * 1024 * 1024;
 function invalidateAssetImports(viteServer, filePath) {
   const timestamp = Date.now();
   for (const environment of Object.values(viteServer.environments)) {
@@ -149,14 +148,20 @@ function astroContentVirtualModPlugin({
         if (id === MODULES_MJS_ID) {
           const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
           if (fs.existsSync(modules)) {
-            return fileURLToPath(modules);
+            return {
+              id: fileURLToPath(modules),
+              meta: createContentDataIncrementalMetadata()
+            };
           }
           return MODULES_MJS_VIRTUAL_ID;
         }
         if (id === ASSET_IMPORTS_VIRTUAL_ID) {
           const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
           if (fs.existsSync(assetImportsFile)) {
-            return fileURLToPath(assetImportsFile);
+            return {
+              id: fileURLToPath(assetImportsFile),
+              meta: createContentDataIncrementalMetadata()
+            };
           }
           return ASSET_IMPORTS_RESOLVED_STUB_ID;
         }
@@ -208,7 +213,10 @@ function astroContentVirtualModPlugin({
         }
         if (id === RESOLVED_DATA_STORE_VIRTUAL_ID) {
           if (!fs.existsSync(dataStoreFile)) {
-            return { code: "export default new Map()" };
+            return {
+              code: "export default new Map()",
+              meta: createContentDataIncrementalMetadata()
+            };
           }
           const jsonData = await fs.promises.readFile(dataStoreFile, "utf-8");
           if (getDataStoreChunkSize(settings) !== void 0) {
@@ -219,36 +227,40 @@ function astroContentVirtualModPlugin({
                 ([collection, parts]) => `${JSON.stringify(collection)}:[${parts.map(chunkImport).join(",")}]`
               );
               const code = `export default{${entries.join(",")}}`;
-              return { code, map: { mappings: "" } };
+              return {
+                code,
+                map: { mappings: "" },
+                meta: createContentDataIncrementalMetadata()
+              };
             } catch (err) {
               const message = "Could not parse data store manifest JSON file";
               this.error({ message, id, cause: err });
             }
           }
           try {
-            const parsed = JSON.parse(jsonData);
-            const useRuntimeJsonParse = isDev && Buffer.byteLength(jsonData) > LARGE_DATA_STORE_THRESHOLD;
-            return {
-              code: useRuntimeJsonParse ? `export default JSON.parse(${JSON.stringify(jsonData)})` : dataToEsm(parsed, {
-                compact: true
-              }),
-              map: { mappings: "" }
-            };
+            JSON.parse(jsonData);
           } catch (err) {
             const message = "Could not parse JSON file";
             this.error({ message, id, cause: err });
           }
+          return {
+            code: `export default JSON.parse(${JSON.stringify(jsonData)})`,
+            map: { mappings: "" },
+            meta: createContentDataIncrementalMetadata()
+          };
         }
         if (id === ASSET_IMPORTS_RESOLVED_STUB_ID) {
           const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
           return {
-            code: fs.existsSync(assetImportsFile) ? fs.readFileSync(assetImportsFile, "utf-8") : "export default new Map()"
+            code: fs.existsSync(assetImportsFile) ? fs.readFileSync(assetImportsFile, "utf-8") : "export default new Map()",
+            meta: createContentDataIncrementalMetadata()
           };
         }
         if (id === MODULES_MJS_VIRTUAL_ID) {
           const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
           return {
-            code: fs.existsSync(modules) ? fs.readFileSync(modules, "utf-8") : "export default new Map()"
+            code: fs.existsSync(modules) ? fs.readFileSync(modules, "utf-8") : "export default new Map()",
+            meta: createContentDataIncrementalMetadata()
           };
         }
       }

package/dist/core/app/entrypoints/index.d.ts

@@ -5,3 +5,5 @@ export { fromRoutingStrategy, toRoutingStrategy } from '../common.js';
 export { createConsoleLogger } from '../../logger/impls/console.js';
 export { deserializeManifest, deserializeRouteData, deserializeRouteInfo, serializeRouteData, serializeRouteInfo, } from '../manifest.js';
 export { AppPipeline } from '../pipeline.js';
+export { beginContentEntryCollection, endContentEntryCollection, } from '../../build/incremental-content-collector.js';
+export { beginImageCollection, endImageCollection, recordStaticImage, } from '../../build/incremental-image-collector.js';