astro 7.2.9 → 7.3.0

package/dist/cli/preview/index.js

@@ -5,6 +5,7 @@ import { resolveRoot } from "../../core/config/config.js";
 import { printHelp } from "../../core/messages/runtime.js";
 import previewServer from "../../core/preview/index.js";
 import { isRunByAgent } from "../agent.js";
+import { isIgnoreLock } from "../dev/index.js";
 import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
 import { background, logs, previewServerCommand, status, stop } from "../server.js";
 async function preview({ flags }) {
@@ -24,6 +25,10 @@ async function preview({ flags }) {
           ["--host", `Listen on all addresses, including LAN and public addresses.`],
           ["--host <custom-address>", `Expose on a network IP address at <custom-address>`],
           ["--open", "Automatically open the app in the browser on server start"],
+          [
+            "--ignore-lock",
+            "Start the preview server even if another one is already running, without checking or writing the lock file."
+          ],
           [
             "--allowed-hosts",
             "Specify a comma-separated list of allowed hosts or allow any hostname."
@@ -41,6 +46,8 @@ async function preview({ flags }) {
   if (agentDetected) {
     flags.json = true;
   }
+  const ignoreLock = isIgnoreLock(flags);
+  const wantsBackground = !!flags.background || agentDetected;
   const logger = createLoggerFromFlags(flags);
   const subcommand = flags._[3]?.toString();
   if (subcommand === "stop") {
@@ -55,7 +62,29 @@ async function preview({ flags }) {
     await logs({ flags, logger, config: previewServerCommand });
     return;
   }
-  if (flags.background || agentDetected) {
+  if (ignoreLock) {
+    if (flags.force) {
+      throw new Error(
+        [
+          "`--force` and `--ignore-lock` cannot be used together.",
+          "",
+          "`--force` replaces the existing preview server; `--ignore-lock` starts a new one alongside it without touching the lock file. Choose one."
+        ].join("\n")
+      );
+    }
+  }
+  if (ignoreLock && wantsBackground) {
+    const reason = flags.background ? "`--background`" : "an auto-detected AI agent environment, which runs the preview server in the background automatically";
+    throw new Error(
+      [
+        `\`--ignore-lock\` cannot be used together with ${reason}.`,
+        "",
+        "Background preview servers rely on the lock file so `astro preview stop`, `astro preview status`, and `astro preview logs` can find them.",
+        "Run the preview server in the foreground to use --ignore-lock."
+      ].join("\n")
+    );
+  }
+  if (wantsBackground) {
     await background({ flags, logger, config: previewServerCommand });
     return;
   }
@@ -69,6 +98,20 @@ Run \`astro preview --help\` to see available commands.`
     process.exit(1);
   }
   const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  if (ignoreLock) {
+    const existingServer2 = await checkExistingServer(root, "preview");
+    if (existingServer2) {
+      logger.info(
+        "SKIP_FORMAT",
+        [
+          `Starting a new preview server alongside the one already running at ${existingServer2.url} (pid ${existingServer2.pid}).`,
+          "This instance is not tracked by `astro preview stop`, `astro preview status`, or `astro preview logs`."
+        ].join("\n")
+      );
+    }
+    const inlineConfig2 = flagsToAstroInlineConfig(flags);
+    return await previewServer(inlineConfig2);
+  }
   const existingServer = await checkExistingServer(root, "preview");
   if (existingServer) {
     const message = [

package/dist/cli/telemetry/index.d.ts

@@ -1,7 +1,8 @@
+import type { AstroLogger } from '../../core/logger/core.js';
 import { type Flags } from '../flags.js';
 interface TelemetryOptions {
     flags: Flags;
 }
-export declare function notify(): Promise<void>;
+export declare function notify(logger: AstroLogger): Promise<void>;
 export declare function update(subcommand: string, { flags }: TelemetryOptions): Promise<void>;
 export {};

package/dist/cli/telemetry/index.js

@@ -1,9 +1,9 @@
 import * as msg from "../../core/messages/runtime.js";
 import { telemetry } from "../../events/index.js";
 import { createLoggerFromFlags } from "../flags.js";
-async function notify() {
+async function notify(logger) {
   await telemetry.notify(() => {
-    console.log(msg.telemetryNotice() + "\n");
+    logger.info("SKIP_FORMAT", msg.telemetryNotice() + "\n");
     return true;
   });
 }

package/dist/content/content-layer.js

@@ -196,7 +196,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.2.9") {
+    if (previousAstroVersion && previousAstroVersion !== "7.3.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.2.9") {
-      this.#store.metaStore().set("astro-version", "7.2.9");
+    if ("7.3.0") {
+      this.#store.metaStore().set("astro-version", "7.3.0");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

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

@@ -8,8 +8,17 @@ export type DataStoreManifest = Record<string, string[]>;
  * (build/dev) and are never imported at runtime.
  */
 export interface DataStoreWriter {
-    /** Serialize and persist the given collections. */
-    write(collections: Map<string, Map<string, any>>): Promise<void>;
+    /**
+     * Serialize and persist the given collections.
+     * Resolves to `true` if the data on disk changed, or `false` if the write
+     * was skipped because the persisted data was already identical.
+     */
+    write(collections: Map<string, Map<string, any>>): Promise<boolean>;
+    /**
+     * The file whose write commits a store update: the store file itself, or
+     * the manifest for chunked stores.
+     */
+    readonly target: PathLike;
 }
 /**
  * Serialize collections to a deterministic devalue string.
@@ -35,15 +44,18 @@ export declare function chunkString(str: string, maxBytes: number): string[];
  * partial reads. If the file already contains identical data, the write is
  * skipped. Callers are responsible for serializing concurrent writes to the
  * same file.
+ *
+ * Returns `true` if the file was written, or `false` if the write was skipped.
  */
-export declare function writeFileAtomic(file: PathLike, data: string): Promise<void>;
+export declare function writeFileAtomic(file: PathLike, data: string): Promise<boolean>;
 /**
  * A {@link DataStoreWriter} that serializes the whole store to a single file.
  */
 export declare class FileWriter implements DataStoreWriter {
     #private;
     constructor(file: PathLike);
-    write(collections: Map<string, Map<string, any>>): Promise<void>;
+    get target(): PathLike;
+    write(collections: Map<string, Map<string, any>>): Promise<boolean>;
 }
 /**
  * A {@link DataStoreWriter} that splits the store across many content-addressed
@@ -60,5 +72,6 @@ export declare class FileWriter implements DataStoreWriter {
 export declare class ChunkedWriter implements DataStoreWriter {
     #private;
     constructor(dir: URL, chunkSize: number);
-    write(collections: Map<string, Map<string, any>>): Promise<void>;
+    get target(): PathLike;
+    write(collections: Map<string, Map<string, any>>): Promise<boolean>;
 }

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

@@ -47,18 +47,22 @@ async function writeFileAtomic(file, data) {
   const tempFile = file instanceof URL ? new URL(`${file.href}.tmp`) : `${file}.tmp`;
   const oldData = await fs.readFile(file, "utf-8").catch(() => "");
   if (oldData === data) {
-    return;
+    return false;
   }
   await fs.writeFile(tempFile, data);
   await fs.rename(tempFile, file);
+  return true;
 }
 class FileWriter {
   #file;
   constructor(file) {
     this.#file = file;
   }
+  get target() {
+    return this.#file;
+  }
   async write(collections) {
-    await writeFileAtomic(this.#file, serializeDataStore(collections));
+    return await writeFileAtomic(this.#file, serializeDataStore(collections));
   }
 }
 class ChunkedWriter {
@@ -72,6 +76,9 @@ class ChunkedWriter {
     this.#manifestFile = new URL(`./${DATA_STORE_MANIFEST_FILE}`, dir);
     this.#chunkSize = chunkSize;
   }
+  get target() {
+    return this.#manifestFile;
+  }
   async write(collections) {
     if (!this.#hasher) {
       this.#hasher = await xxhash();
@@ -81,9 +88,10 @@ class ChunkedWriter {
     for (const [collectionName, entries] of sortCollections(collections)) {
       manifest[collectionName] = await this.#writeCollection(entries);
     }
-    await writeFileAtomic(this.#manifestFile, JSON.stringify(manifest));
+    const didWrite = await writeFileAtomic(this.#manifestFile, JSON.stringify(manifest));
     this.#writtenFiles.add(DATA_STORE_MANIFEST_FILE);
     emptyDir(this.#dir, this.#writtenFiles);
+    return didWrite;
   }
   async #writeCollection(entries) {
     const parts = [];

package/dist/content/index.d.ts

@@ -3,4 +3,4 @@ export { createContentTypesGenerator } from './types-generator.js';
 export { getContentPaths } from './utils.js';
 export { astroContentAssetPropagationPlugin } from './vite-plugin-content-assets.js';
 export { astroContentImportPlugin } from './vite-plugin-content-imports.js';
-export { astroContentVirtualModPlugin } from './vite-plugin-content-virtual-mod.js';
+export { astroContentVirtualModPlugin, attachDataStoreInvalidation, } from './vite-plugin-content-virtual-mod.js';

package/dist/content/index.js

@@ -3,12 +3,16 @@ import { createContentTypesGenerator } from "./types-generator.js";
 import { getContentPaths } from "./utils.js";
 import { astroContentAssetPropagationPlugin } from "./vite-plugin-content-assets.js";
 import { astroContentImportPlugin } from "./vite-plugin-content-imports.js";
-import { astroContentVirtualModPlugin } from "./vite-plugin-content-virtual-mod.js";
+import {
+  astroContentVirtualModPlugin,
+  attachDataStoreInvalidation
+} from "./vite-plugin-content-virtual-mod.js";
 export {
   astroContentAssetPropagationPlugin,
   astroContentImportPlugin,
   astroContentVirtualModPlugin,
   attachContentServerListeners,
+  attachDataStoreInvalidation,
   createContentTypesGenerator,
   getContentPaths
 };

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

@@ -1,4 +1,5 @@
 import { type PathLike } from 'node:fs';
+import type { AstroLogger } from '../core/logger/core.js';
 import { type DataEntry, ImmutableDataStore } from './data-store.js';
 /**
  * Extends the DataStore with the ability to change entries and write them to disk.
@@ -6,6 +7,17 @@ import { type DataEntry, ImmutableDataStore } from './data-store.js';
  */
 export declare class MutableDataStore extends ImmutableDataStore {
     #private;
+    /**
+     * Registers a listener called with the file path whenever this store writes a
+     * file to disk (the data store itself, or the asset/module import files).
+     * Writes that are skipped because the data on disk is already identical do
+     * not notify. The dev server uses this to invalidate the content virtual
+     * modules deterministically, instead of relying on the file watcher to
+     * observe the write — on some platforms (notably Windows) the watcher can
+     * miss the atomic rename that commits it.
+     * Returns a function that removes the listener.
+     */
+    onFileWritten(listener: (path: string) => void): () => void;
     set(collectionName: string, key: string, value: unknown): void;
     delete(collectionName: string, key: string): void;
     clear(collectionName: string): void;
@@ -42,7 +54,7 @@ export declare class MutableDataStore extends ImmutableDataStore {
      * 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, chunkSize: number): Promise<MutableDataStore>;
+    static fromDir(dirPath: URL, chunkSize: number, logger: Pick<AstroLogger, 'warn'>): 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

@@ -30,6 +30,32 @@ class MutableDataStore extends ImmutableDataStore {
   #moduleImports = /* @__PURE__ */ new Map();
   #writeInProgress = false;
   #writeQueued = false;
+  #fileWrittenListeners = /* @__PURE__ */ new Set();
+  /**
+   * Registers a listener called with the file path whenever this store writes a
+   * file to disk (the data store itself, or the asset/module import files).
+   * Writes that are skipped because the data on disk is already identical do
+   * not notify. The dev server uses this to invalidate the content virtual
+   * modules deterministically, instead of relying on the file watcher to
+   * observe the write — on some platforms (notably Windows) the watcher can
+   * miss the atomic rename that commits it.
+   * Returns a function that removes the listener.
+   */
+  onFileWritten(listener) {
+    this.#fileWrittenListeners.add(listener);
+    return () => {
+      this.#fileWrittenListeners.delete(listener);
+    };
+  }
+  #notifyFileWritten(path) {
+    if (this.#fileWrittenListeners.size === 0) {
+      return;
+    }
+    const normalized = path instanceof URL ? fileURLToPath(path) : path.toString();
+    for (const listener of this.#fileWrittenListeners) {
+      listener(normalized);
+    }
+  }
   set(collectionName, key, value) {
     const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
     collection.set(String(key), value);
@@ -275,6 +301,7 @@ ${lines.join(",\n")}]);
       }
       await fs.writeFile(tempFile, data);
       await fs.rename(tempFile, filePath);
+      this.#notifyFileWritten(filePath);
     } finally {
       this.#writing.delete(fileKey);
       if (this.#pending.has(fileKey)) {
@@ -415,7 +442,10 @@ ${lines.join(",\n")}]);
     try {
       this.#dirty = false;
       this.#writeInProgress = true;
-      await this.#writer.write(this._collections);
+      const didWrite = await this.#writer.write(this._collections);
+      if (didWrite) {
+        this.#notifyFileWritten(this.#writer.target);
+      }
     } catch (err) {
       throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
     } finally {
@@ -471,7 +501,7 @@ ${lines.join(",\n")}]);
    * 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, chunkSize) {
+  static async fromDir(dirPath, chunkSize, logger) {
     const manifestFile = new URL(`./${DATA_STORE_MANIFEST_FILE}`, dirPath);
     if (existsSync(manifestFile)) {
       try {
@@ -489,9 +519,9 @@ ${lines.join(",\n")}]);
         store2.#writer = new ChunkedWriter(dirPath, chunkSize);
         return store2;
       } catch (err) {
-        console.warn(
-          `[content] Could not read the chunked data store at ${fileURLToPath(dirPath)}, rebuilding from scratch.`,
-          err
+        logger.warn(
+          "content",
+          `Could not read the chunked data store at ${fileURLToPath(dirPath)}, rebuilding from scratch. ${err instanceof Error ? err.message : err}`
         );
       }
     }

package/dist/content/runtime.d.ts

@@ -8,14 +8,16 @@ import type { LIVE_CONTENT_TYPE } from './consts.js';
 import { type DataEntry } from './data-store.js';
 import { LiveCollectionCacheHintError, LiveCollectionError, LiveCollectionValidationError, LiveEntryNotFoundError } from './loaders/errors.js';
 import type { LiveLoader } from './loaders/types.js';
+import type { AstroLogger } from '../core/logger/core.js';
 export { LiveCollectionError, LiveCollectionCacheHintError, LiveEntryNotFoundError, LiveCollectionValidationError, };
 type LiveCollectionConfigMap = Record<string, {
     loader: LiveLoader;
     type: typeof LIVE_CONTENT_TYPE;
     schema?: zCore.$ZodType;
 }>;
-export declare function createGetCollection({ liveCollections, }: {
+export declare function createGetCollection({ liveCollections, logger, }: {
     liveCollections: LiveCollectionConfigMap;
+    logger: AstroLogger;
 }): (collection: string, filter?: ((entry: any) => unknown) | Record<string, unknown>) => Promise<{
     data: Record<string, unknown>;
     collection: string;
@@ -50,8 +52,9 @@ type EntryLookupObject = {
     collection: string;
     slug: string;
 };
-export declare function createGetEntry({ liveCollections }: {
+export declare function createGetEntry({ liveCollections, logger, }: {
     liveCollections: LiveCollectionConfigMap;
+    logger: AstroLogger;
 }): (collectionOrLookupObject: string | EntryLookupObject, lookup?: string | Record<string, unknown>) => Promise<ContentEntryResult | DataEntryResult | undefined>;
 export declare function createGetEntries(getEntry: ReturnType<typeof createGetEntry>): (entries: {
     collection: string;
@@ -73,7 +76,9 @@ type RenderResult = {
 };
 export declare function updateImageReferencesInData<T extends Record<string, unknown>>(data: T, fileName?: string, imageAssetMap?: Map<string, ImageMetadata>, imageImports?: (string | number)[][]): 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 createRenderEntry({ logger }: {
+    logger: AstroLogger;
+}): (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;
     collection: z.ZodString;

package/dist/content/runtime.js

@@ -2,7 +2,7 @@ import { escape } from "html-escaper";
 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 { recordContentEntryRender } from "../core/render-scope/record.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { isRemotePath, prependForwardSlash } from "../core/path.js";
 import {
@@ -61,7 +61,8 @@ async function parseLiveEntry(entry, schema, collection) {
   }
 }
 function createGetCollection({
-  liveCollections
+  liveCollections,
+  logger
 }) {
   return async function getCollection(collection, filter) {
     if (collection in liveCollections) {
@@ -89,7 +90,8 @@ function createGetCollection({
       }
       return result;
     } else {
-      console.warn(
+      logger.warn(
+        "content",
         `The collection ${JSON.stringify(
           collection
         )} does not exist or is empty. Please check your content config file for errors.`
@@ -98,7 +100,10 @@ function createGetCollection({
     }
   };
 }
-function createGetEntry({ liveCollections }) {
+function createGetEntry({
+  liveCollections,
+  logger
+}) {
   return async function getEntry(collectionOrLookupObject, lookup) {
     let collection, lookupId;
     if (typeof collectionOrLookupObject === "string") {
@@ -129,7 +134,7 @@ function createGetEntry({ liveCollections }) {
     if (await store.hasCollection(collection)) {
       const entry = await store.get(collection, lookupId);
       if (!entry) {
-        console.warn(`Entry ${collection} \u2192 ${lookupId} was not found.`);
+        logger.warn("content", `Entry ${collection} \u2192 ${lookupId} was not found.`);
         return;
       }
       const { default: imageAssetMap } = await import("astro:asset-imports");
@@ -140,12 +145,14 @@ function createGetEntry({ liveCollections }) {
         collection
       };
       warnForPropertyAccess(
+        logger,
         result.data,
         "slug",
         `[content] Attempted to access deprecated property on "${collection}" entry.
 The "slug" property is no longer automatically added to entries. Please use the "id" property instead.`
       );
       warnForPropertyAccess(
+        logger,
         result,
         "render",
         `[content] Invalid attempt to access "render()" method on "${collection}" entry.
@@ -156,13 +163,13 @@ To render an entry, use "render(entry)" from "astro:content".`
     return void 0;
   };
 }
-function warnForPropertyAccess(entry, prop, message) {
+function warnForPropertyAccess(logger, entry, prop, message) {
   if (!(prop in entry)) {
     let _value = void 0;
     Object.defineProperty(entry, prop, {
       get() {
         if (_value === void 0) {
-          console.error(message);
+          logger.error("content", message);
         }
         return _value;
       },
@@ -349,7 +356,9 @@ async function updateImageReferencesInBody(html, fileName) {
     return Object.entries({
       ...attributes,
       src: image.src,
-      srcset: image.srcSet.attribute,
+      // An empty `srcset` is invalid HTML, so only emit it when there are
+      // actual candidates. This matches `vite-plugin-markdown/images.ts`.
+      ...image.srcSet.values.length > 0 ? { srcset: image.srcSet.attribute } : {},
       // This attribute is used by the toolbar audit
       ...import.meta.env.DEV ? { "data-image-component": "true" } : {}
     }).filter(([, value]) => value != null).map(([key, value]) => value === "" ? `${key}=""` : `${key}="${escape(String(value))}"`).join(" ");
@@ -402,30 +411,32 @@ function updateImageReferencesInData(data, fileName, imageAssetMap, imageImports
 function resolveEntryData(entry, imageAssetMap) {
   return updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap, entry.imageImports);
 }
-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");
-      const renderEntryImport = contentModules.get(entry.filePath);
-      return render({
-        collection: "",
-        id: entry.id,
-        renderEntryImport
-      });
-    } catch (e) {
-      console.error(e);
+function createRenderEntry({ logger }) {
+  return async function renderEntry(entry) {
+    if (!entry) {
+      throw new AstroError(AstroErrorData.RenderUndefinedEntryError);
     }
-  }
-  const html = entry?.rendered?.metadata?.imagePaths?.length && entry.filePath ? await updateImageReferencesInBody(entry.rendered.html, entry.filePath) : entry?.rendered?.html;
-  const Content = createComponent(() => serverRender`${unescapeHTML(html)}`);
-  return {
-    Content,
-    headings: entry?.rendered?.metadata?.headings ?? [],
-    remarkPluginFrontmatter: entry?.rendered?.metadata?.frontmatter ?? {}
+    recordContentEntryRender(entry.filePath);
+    if (entry.deferredRender) {
+      try {
+        const { default: contentModules } = await import("astro:content-module-imports");
+        const renderEntryImport = contentModules.get(entry.filePath);
+        return render({
+          collection: "",
+          id: entry.id,
+          renderEntryImport
+        });
+      } catch (e) {
+        logger.error("content", `${e}`);
+      }
+    }
+    const html = entry?.rendered?.metadata?.imagePaths?.length && entry.filePath ? await updateImageReferencesInBody(entry.rendered.html, entry.filePath) : entry?.rendered?.html;
+    const Content = createComponent(() => serverRender`${unescapeHTML(html)}`);
+    return {
+      Content,
+      headings: entry?.rendered?.metadata?.headings ?? [],
+      remarkPluginFrontmatter: entry?.rendered?.metadata?.frontmatter ?? {}
+    };
   };
 }
 async function render({
@@ -580,9 +591,9 @@ export {
   createGetLiveCollection,
   createGetLiveEntry,
   createReference,
+  createRenderEntry,
   defineCollection,
   defineLiveCollection,
-  renderEntry,
   resolveEntryData,
   updateImageReferencesInData
 };

package/dist/content/types-generator.js

@@ -85,7 +85,8 @@ async function createContentTypesGenerator({
       await reloadContentConfigObserver({
         fs,
         settings,
-        environment: viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro]
+        environment: viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro],
+        logger
       });
       return { shouldGenerateTypes: true };
     }

package/dist/content/utils.d.ts

@@ -12,38 +12,7 @@ export declare const loaderReturnSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodOb
 }, z.core.$loose>>, z.ZodRecord<z.ZodString, z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>>]>;
-declare const collectionConfigParser: z.ZodUnion<readonly [z.ZodObject<{
-    type: z.ZodOptional<z.ZodLiteral<"content">>;
-    schema: z.ZodOptional<z.ZodAny>;
-    loader: z.ZodOptional<z.ZodNever>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodOptional<z.ZodLiteral<"data">>;
-    schema: z.ZodOptional<z.ZodAny>;
-    loader: z.ZodOptional<z.ZodNever>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"content_layer">;
-    schema: z.ZodOptional<z.ZodAny>;
-    loader: z.ZodUnion<readonly [z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>, z.ZodObject<{
-        name: z.ZodString;
-        load: z.ZodFunction<z.ZodTuple<readonly [z.ZodCustom<LoaderContext, LoaderContext>], null>, z.ZodCustom<void | {
-            schema?: any;
-            types?: string;
-        }, void | {
-            schema?: any;
-            types?: string;
-        }>>;
-        schema: z.ZodOptional<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>>;
-        createSchema: z.ZodOptional<z.ZodFunction<z.ZodTuple<readonly [], null>, z.ZodPromise<z.ZodObject<{
-            schema: z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-            types: z.ZodString;
-        }, z.core.$strip>>>>;
-    }, z.core.$strip>]>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"live">>>;
-    schema: z.ZodOptional<z.ZodAny>;
-    loader: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
-}, z.core.$strip>]>;
-declare const contentConfigParser: z.ZodObject<{
+declare function contentConfigParser(logger: AstroLogger): z.ZodObject<{
     collections: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodOptional<z.ZodLiteral<"content">>;
         schema: z.ZodOptional<z.ZodAny>;
@@ -66,7 +35,7 @@ declare const contentConfigParser: z.ZodObject<{
             }>>;
             schema: z.ZodOptional<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>>;
             createSchema: z.ZodOptional<z.ZodFunction<z.ZodTuple<readonly [], null>, z.ZodPromise<z.ZodObject<{
-                schema: z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+                schema: z.ZodCustom<z.ZodSchema<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodSchema<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
                 types: z.ZodString;
             }, z.core.$strip>>>>;
         }, z.core.$strip>]>;
@@ -76,10 +45,10 @@ declare const contentConfigParser: z.ZodObject<{
         loader: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
     }, z.core.$strip>]>>;
 }, z.core.$strip>;
-export type CollectionConfig = z.infer<typeof collectionConfigParser>;
-export type ContentConfig = z.infer<typeof contentConfigParser> & {
+export type ContentConfig = z.infer<ReturnType<typeof contentConfigParser>> & {
     digest?: string;
 };
+export type CollectionConfig = ContentConfig['collections'][string];
 type EntryInternal = {
     rawData: string | undefined;
     filePath: string;
@@ -138,6 +107,7 @@ export declare function reloadContentConfigObserver({ observer, ...loadContentCo
     settings: AstroSettings;
     environment: RunnableDevEnvironment;
     observer?: ContentObservable;
+    logger: AstroLogger;
 }): Promise<void>;
 type ContentCtx = {
     status: 'init';