astro 7.2.10 → 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.10") {
+    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.10") {
-      this.#store.metaStore().set("astro-version", "7.2.10");
+    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/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.
@@ -53,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

@@ -501,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 {
@@ -519,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;
       },
@@ -404,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({
@@ -582,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';

package/dist/content/utils.js

@@ -36,66 +36,71 @@ const loaderReturnSchema = z.union([
     }).passthrough()
   )
 ]);
-const collectionConfigParser = z.union([
-  z.object({
-    type: z.literal("content").optional(),
-    schema: z.any().optional(),
-    loader: z.never().optional()
-  }),
-  z.object({
-    type: z.literal("data").optional(),
-    schema: z.any().optional(),
-    loader: z.never().optional()
-  }),
-  z.object({
-    type: z.literal(CONTENT_LAYER_TYPE),
-    schema: z.any().optional(),
-    loader: z.union([
-      z.function(),
-      z.object({
-        name: z.string(),
-        load: z.function({
-          input: [z.custom()],
-          output: z.custom()
+function contentConfigParser(logger) {
+  return z.object({
+    collections: z.record(
+      z.string(),
+      z.union([
+        z.object({
+          type: z.literal("content").optional(),
+          schema: z.any().optional(),
+          loader: z.never().optional()
         }),
-        schema: z.any().transform((v) => {
-          if (typeof v === "function") {
-            console.warn(
-              `Your loader's schema is defined using a function. This is no longer supported and the schema will be ignored. Please update your loader to use the \`createSchema()\` utility instead, or report this to the loader author. In a future major version, this will cause the loader to break entirely.`
-            );
-            return void 0;
-          }
-          return v;
-        }).superRefine((v, ctx) => {
-          if (v !== void 0 && !("_zod" in v)) {
-            ctx.addIssue({
-              code: z.ZodIssueCode.custom,
-              message: "Invalid Zod schema"
-            });
-            return z.NEVER;
-          }
-        }).optional(),
-        createSchema: z.function({
-          input: [],
-          output: z.promise(
+        z.object({
+          type: z.literal("data").optional(),
+          schema: z.any().optional(),
+          loader: z.never().optional()
+        }),
+        z.object({
+          type: z.literal(CONTENT_LAYER_TYPE),
+          schema: z.any().optional(),
+          loader: z.union([
+            z.function(),
             z.object({
-              schema: z.custom((v) => "_zod" in v),
-              types: z.string()
+              name: z.string(),
+              load: z.function({
+                input: [z.custom()],
+                output: z.custom()
+              }),
+              schema: z.any().transform((v) => {
+                if (typeof v === "function") {
+                  logger.warn(
+                    "content",
+                    `Your loader's schema is defined using a function. This is no longer supported and the schema will be ignored. Please update your loader to use the \`createSchema()\` utility instead, or report this to the loader author. In a future major version, this will cause the loader to break entirely.`
+                  );
+                  return void 0;
+                }
+                return v;
+              }).superRefine((v, ctx) => {
+                if (v !== void 0 && !("_zod" in v)) {
+                  ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: "Invalid Zod schema"
+                  });
+                  return z.NEVER;
+                }
+              }).optional(),
+              createSchema: z.function({
+                input: [],
+                output: z.promise(
+                  z.object({
+                    schema: z.custom((v) => "_zod" in v),
+                    types: z.string()
+                  })
+                )
+              }).optional()
             })
-          )
-        }).optional()
-      })
-    ])
-  }),
-  z.object({
-    type: z.literal(LIVE_CONTENT_TYPE).optional().default(LIVE_CONTENT_TYPE),
-    schema: z.any().optional(),
-    loader: z.function()
-  })
-]);
-const contentConfigParser = z.object({
-  collections: z.record(z.string(), collectionConfigParser)
-});
+          ])
+        }),
+        z.object({
+          type: z.literal(LIVE_CONTENT_TYPE).optional().default(LIVE_CONTENT_TYPE),
+          schema: z.any().optional(),
+          loader: z.function()
+        })
+      ])
+    )
+  });
+}
 function parseEntrySlug({
   id,
   collection,
@@ -358,7 +363,8 @@ function isDeferredModule(viteId) {
 async function loadContentConfig({
   fs,
   settings,
-  environment
+  environment,
+  logger
 }) {
   const contentPaths = getContentPaths(
     settings.config,
@@ -370,19 +376,17 @@ async function loadContentConfig({
   }
   const configPathname = fileURLToPath(contentPaths.config.url);
   const unparsedConfig = await environment.runner.import(configPathname);
-  const config = contentConfigParser.safeParse(unparsedConfig);
+  const config = contentConfigParser(logger).safeParse(unparsedConfig);
   if (config.success) {
     const hasher = await xxhash();
     const digest = hasher.h64ToString(await fs.promises.readFile(configPathname, "utf-8"));
     return { ...config.data, digest };
   } else {
     const message = config.error.issues.map((issue) => `  \u2192 ${colors.green(issue.path.join("."))}: ${colors.red(issue.message)}`).join("\n");
-    console.error(
-      `${colors.green("[content]")} There was a problem with your content config:
+    logger.error("content", `There was a problem with your content config:
 
 ${message}
-`
-    );
+`);
     const liveCollections = Object.entries(unparsedConfig.collections ?? {}).filter(
       ([, collection]) => collection?.type === LIVE_CONTENT_TYPE
     );
@@ -401,7 +405,8 @@ ${message}
 async function autogenerateCollections({
   config,
   settings,
-  fs
+  fs,
+  logger
 }) {
   if (!config) {
     return config;
@@ -455,7 +460,8 @@ async function autogenerateCollections({
       }
     }
     if (orphanedCollections.length > 0) {
-      console.warn(
+      logger.warn(
+        "SKIP_FORMAT",
         `
 Auto-generating collections for folders in "src/content/" that are not defined as collections.
 This is deprecated, so you should define these collections yourself in "src/content.config.ts".

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

@@ -138,7 +138,8 @@ export const _internal = {
               await reloadContentConfigObserver({
                 fs,
                 settings,
-                environment: viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro]
+                environment: viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro],
+                logger
               });
             }
             for (const modUrl of environment.moduleGraph.urlToModuleMap.keys()) {

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

@@ -4,5 +4,7 @@ export { BaseApp, type RenderErrorOptions, type RenderOptions, type LogRequestPa
 export { fromRoutingStrategy, toRoutingStrategy } from '../common.js';
 export { createConsoleLogger } from '../../logger/impls/console.js';
 export { deserializeManifest, deserializeRouteData, deserializeRouteInfo, serializeRouteData, serializeRouteInfo, } from '../manifest.js';
-export { beginContentEntryCollection, endContentEntryCollection, } from '../../build/incremental-content-collector.js';
-export { beginImageCollection, endImageCollection, recordStaticImage, } from '../../build/incremental-image-collector.js';
+export { getInstalledRenderScope, installRenderScope, type RenderCollectors, type RenderCollectorScope, } from '../../render-scope/scope.js';
+export { recordStaticImage } from '../../render-scope/record.js';
+export { collectPrerenderMetadata, type CollectedPrerenderMetadata, } from '../../render-scope/collect.js';
+export { renderForPrerender, type PrerenderableApp, type PrerenderRenderOptions, } from '../prerender.js';