astro 7.1.5 → 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/consts.d.ts

@@ -28,3 +28,7 @@ export declare const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";
 export declare const COLLECTIONS_DIR = "collections/";
 export declare const CONTENT_LAYER_TYPE = "content_layer";
 export declare const LIVE_CONTENT_TYPE = "live";
+export declare const DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX = "astro:data-layer-content-chunk:";
+export declare const RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX = "\0astro:data-layer-content-chunk:";
+export declare const RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX = ".mjs";
+export declare const DATA_STORE_CHUNK_FILE_NAME_PATTERN: RegExp;

package/dist/content/consts.js

@@ -35,6 +35,10 @@ const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";
 const COLLECTIONS_DIR = "collections/";
 const CONTENT_LAYER_TYPE = "content_layer";
 const LIVE_CONTENT_TYPE = "live";
+const DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX = `${DATA_STORE_VIRTUAL_ID}-chunk:`;
+const RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX = `\0${DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX}`;
+const RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX = ".mjs";
+const DATA_STORE_CHUNK_FILE_NAME_PATTERN = /^[a-f0-9]{16}\.txt$/;
 export {
   ASSET_IMPORTS_FILE,
   ASSET_IMPORTS_RESOLVED_STUB_ID,
@@ -49,6 +53,8 @@ export {
   CONTENT_RENDER_FLAG,
   CONTENT_TYPES_FILE,
   DATA_FLAG,
+  DATA_STORE_CHUNK_FILE_NAME_PATTERN,
+  DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX,
   DATA_STORE_DIR,
   DATA_STORE_FILE,
   DATA_STORE_MANIFEST_FILE,
@@ -62,6 +68,8 @@ export {
   MODULES_MJS_VIRTUAL_ID,
   PROPAGATED_ASSET_FLAG,
   PROPAGATED_ASSET_QUERY_PARAM,
+  RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_PREFIX,
+  RESOLVED_DATA_STORE_CHUNK_VIRTUAL_ID_SUFFIX,
   RESOLVED_DATA_STORE_VIRTUAL_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
   STYLES_PLACEHOLDER,

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.5") {
+    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.5") {
-      this.#store.metaStore().set("astro-version", "7.1.5");
+    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/data-store-writer.d.ts

@@ -62,6 +62,6 @@ export declare class FileWriter implements DataStoreWriter {
  */
 export declare class ChunkedWriter implements DataStoreWriter {
     #private;
-    constructor(dir: URL);
+    constructor(dir: URL, chunkSize: number);
     write(collections: Map<string, Map<string, any>>): Promise<void>;
 }

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

@@ -3,7 +3,6 @@ import * as devalue from "devalue";
 import xxhash, {} from "xxhash-wasm";
 import { emptyDir } from "../core/fs/index.js";
 import { DATA_STORE_MANIFEST_FILE } from "./consts.js";
-const CHUNK_SIZE_LIMIT = 20 * 1024 * 1024;
 function sortCollections(collections) {
   return new Map(
     [...collections.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([key, collection]) => [
@@ -57,10 +56,12 @@ class FileWriter {
 class ChunkedWriter {
   #dir;
   #manifestFile;
+  #chunkSize;
   #hasher;
-  constructor(dir) {
+  constructor(dir, chunkSize) {
     this.#dir = dir;
     this.#manifestFile = new URL(`./${DATA_STORE_MANIFEST_FILE}`, dir);
+    this.#chunkSize = chunkSize;
   }
   async write(collections) {
     if (!this.#hasher) {
@@ -72,7 +73,7 @@ class ChunkedWriter {
     for (const [collectionName, entries] of sortCollections(collections)) {
       const stringified = devalue.stringify(entries);
       const parts = [];
-      for (const part of chunkString(stringified, CHUNK_SIZE_LIMIT)) {
+      for (const part of chunkString(stringified, this.#chunkSize)) {
         const fileName = `${h64ToString(part)}.txt`;
         await writeFileAtomic(new URL(`./${fileName}`, this.#dir), part);
         parts.push(fileName);

package/dist/content/data-store.d.ts

@@ -51,9 +51,9 @@ export declare class ImmutableDataStore {
      * names have already been swapped for their contents.
      *
      * Each collection maps to a list of parts. A part is either a raw string
-     * (when the store is loaded from disk) or an ESM namespace from a `?raw`
-     * import (`{ default: string }`, when emitted into the virtual module at
-     * runtime). A collection's parts are concatenated back into the exact
+     * (when the store is loaded from disk) or an ESM namespace from a virtual
+     * chunk import (`{ default: string }`, when emitted at runtime). A collection's
+     * parts are concatenated back into the exact
      * serialized string, then parsed with devalue. This is the inverse of
      * {@link import('./data-store-writer.js').ChunkedWriter} and stays free of
      * Node built-ins so it can run at runtime.

package/dist/content/data-store.js

@@ -38,9 +38,9 @@ class ImmutableDataStore {
    * names have already been swapped for their contents.
    *
    * Each collection maps to a list of parts. A part is either a raw string
-   * (when the store is loaded from disk) or an ESM namespace from a `?raw`
-   * import (`{ default: string }`, when emitted into the virtual module at
-   * runtime). A collection's parts are concatenated back into the exact
+   * (when the store is loaded from disk) or an ESM namespace from a virtual
+   * chunk import (`{ default: string }`, when emitted at runtime). A collection's
+   * parts are concatenated back into the exact
    * serialized string, then parsed with devalue. This is the inverse of
    * {@link import('./data-store-writer.js').ChunkedWriter} and stays free of
    * Node built-ins so it can run at runtime.

package/dist/content/mutable-data-store.d.ts

@@ -36,13 +36,13 @@ export declare class MutableDataStore extends ImmutableDataStore {
     static fromString(data: string): Promise<MutableDataStore>;
     static fromFile(filePath: string | URL): Promise<MutableDataStore>;
     /**
-     * Loads a MutableDataStore from a chunked store directory (experimental
-     * `collectionStorage: 'chunked'`), reading the manifest and its referenced parts.
+     * Loads a MutableDataStore from a chunked store directory, reading the manifest
+     * and its referenced parts.
      * If the directory has no manifest yet (fresh build) it starts empty. If the
      * manifest exists but can't be read (corrupt cache), it warns and starts
      * empty so loaders rebuild it, rather than failing the sync.
      */
-    static fromDir(dirPath: URL): Promise<MutableDataStore>;
+    static fromDir(dirPath: URL, chunkSize: number): Promise<MutableDataStore>;
 }
 export interface DataStore {
     get: <TData extends Record<string, unknown> = Record<string, unknown>>(key: string) => DataEntry<TData> | undefined;

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

@@ -412,13 +412,13 @@ ${lines.join(",\n")}]);
     return store;
   }
   /**
-   * Loads a MutableDataStore from a chunked store directory (experimental
-   * `collectionStorage: 'chunked'`), reading the manifest and its referenced parts.
+   * Loads a MutableDataStore from a chunked store directory, reading the manifest
+   * and its referenced parts.
    * If the directory has no manifest yet (fresh build) it starts empty. If the
    * manifest exists but can't be read (corrupt cache), it warns and starts
    * empty so loaders rebuild it, rather than failing the sync.
    */
-  static async fromDir(dirPath) {
+  static async fromDir(dirPath, chunkSize) {
     const manifestFile = new URL(`./${DATA_STORE_MANIFEST_FILE}`, dirPath);
     if (existsSync(manifestFile)) {
       try {
@@ -434,7 +434,7 @@ ${lines.join(",\n")}]);
         }
         const map = ImmutableDataStore.manifestToMap(expanded);
         const store2 = await MutableDataStore.fromMap(map);
-        store2.#writer = new ChunkedWriter(dirPath);
+        store2.#writer = new ChunkedWriter(dirPath, chunkSize);
         return store2;
       } catch (err) {
         console.warn(
@@ -445,7 +445,7 @@ ${lines.join(",\n")}]);
     }
     await fs.mkdir(dirPath, { recursive: true });
     const store = new MutableDataStore();
-    store.#writer = new ChunkedWriter(dirPath);
+    store.#writer = new ChunkedWriter(dirPath, chunkSize);
     return store;
   }
 }

package/dist/content/paths.d.ts

@@ -5,9 +5,10 @@ import type { AstroSettings } from '../types/astro.js';
  * In production, it's in the cache directory so that it's preserved between builds.
  */
 export declare function getDataStoreFile(settings: AstroSettings, isDev: boolean): URL;
+export declare function getDataStoreChunkSize(settings: AstroSettings): number | undefined;
 /**
  * Get the path to the data store directory, used when the store is split across
- * multiple files (experimental `collectionStorage: 'chunked'`).
+ * multiple files.
  * During development, this is in the `.astro` directory so that the Vite watcher can see it.
  * In production, it's in the cache directory so that it's preserved between builds.
  */

package/dist/content/paths.js

@@ -2,10 +2,21 @@ import { DATA_STORE_DIR, DATA_STORE_FILE } from "./consts.js";
 function getDataStoreFile(settings, isDev) {
   return new URL(DATA_STORE_FILE, isDev ? settings.dotAstroDir : settings.config.cacheDir);
 }
+function getDataStoreChunkSize(settings) {
+  const storage = settings.config.experimental.collectionStorage;
+  if (storage === void 0 || storage === "single-file") {
+    return void 0;
+  }
+  if (storage === "chunked") {
+    return 20 * 1024 * 1024;
+  }
+  return storage.chunkSize;
+}
 function getDataStoreDir(settings, isDev) {
   return new URL(DATA_STORE_DIR, isDev ? settings.dotAstroDir : settings.config.cacheDir);
 }
 export {
+  getDataStoreChunkSize,
   getDataStoreDir,
   getDataStoreFile
 };

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");