astro 6.0.0-alpha.3 → 6.0.0-alpha.5

package/dist/assets/build/generate.js

@@ -28,7 +28,7 @@ async function prepareAssetsGenerationEnv(app, totalCount) {
   const isServerOutput = settings.buildOutput === "server";
   let serverRoot, clientRoot;
   if (isServerOutput) {
-    serverRoot = manifest.buildServerDir;
+    serverRoot = new URL(".prerender/", manifest.buildServerDir);
     clientRoot = manifest.buildClientDir;
   } else {
     serverRoot = getOutDirWithinCwd(manifest.outDir);

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "6.0.0-alpha.3";
+  version = "6.0.0-alpha.5";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/config.d.ts

@@ -43,11 +43,6 @@ export type { ImageFunction };
 export type SchemaContext = {
     image: ImageFunction;
 };
-export type LiveCollectionConfig<L extends LiveLoader, S extends BaseSchema | undefined = undefined> = {
-    type?: 'live';
-    schema?: S;
-    loader: L;
-};
 type LoaderConstraint<TData extends {
     id: string;
 }> = Loader | (() => Array<TData> | Promise<Array<TData>> | Record<string, Omit<TData, 'id'> & {
@@ -55,14 +50,35 @@ type LoaderConstraint<TData extends {
 }> | Promise<Record<string, Omit<TData, 'id'> & {
     id?: string;
 }>>);
-export type CollectionConfig<TSchema extends BaseSchema, TLoader extends LoaderConstraint<{
+type ContentLayerConfig<S extends BaseSchema, TLoader extends LoaderConstraint<{
     id: string;
 }>> = {
     type?: 'content_layer';
-    schema?: TSchema | ((context: SchemaContext) => TSchema);
+    schema?: S | ((context: SchemaContext) => S);
     loader: TLoader;
 };
+type DataCollectionConfig<S extends BaseSchema> = {
+    type: 'data';
+    schema?: S | ((context: SchemaContext) => S);
+};
+type ContentCollectionConfig<S extends BaseSchema> = {
+    type?: 'content';
+    schema?: S | ((context: SchemaContext) => S);
+    loader?: never;
+};
+export type LiveCollectionConfig<L extends LiveLoader, S extends BaseSchema | undefined = undefined> = {
+    type?: 'live';
+    schema?: S;
+    loader: L;
+};
+export type CollectionConfig<S extends BaseSchema, TLoader extends LoaderConstraint<{
+    id: string;
+}> = LoaderConstraint<{
+    id: string;
+}>> = ContentCollectionConfig<S> | DataCollectionConfig<S> | ContentLayerConfig<S, TLoader>;
 export declare function defineLiveCollection<L extends LiveLoader, S extends BaseSchema | undefined = undefined>(config: LiveCollectionConfig<L, S>): LiveCollectionConfig<L, S>;
-export declare function defineCollection<TSchema extends BaseSchema, TLoader extends LoaderConstraint<{
+export declare function defineCollection<S extends BaseSchema, TLoader extends LoaderConstraint<{
+    id: string;
+}> = LoaderConstraint<{
     id: string;
-}>>(config: CollectionConfig<TSchema, TLoader>): CollectionConfig<TSchema, TLoader>;
+}>>(config: CollectionConfig<S, TLoader>): CollectionConfig<S, TLoader>;

package/dist/content/config.js

@@ -71,24 +71,20 @@ function defineCollection(config) {
       )
     });
   }
-  if (!("loader" in config)) {
-    throw new AstroError({
-      ...AstroErrorData.ContentCollectionMissingLoader,
-      message: AstroErrorData.ContentCollectionMissingLoader.message(importerFilename)
-    });
-  }
-  if (config.type && config.type !== CONTENT_LAYER_TYPE) {
-    throw new AstroError({
-      ...AstroErrorData.ContentCollectionInvalidType,
-      message: AstroErrorData.ContentCollectionInvalidType.message(config.type, importerFilename)
-    });
-  }
-  if (typeof config.loader === "object" && typeof config.loader.load !== "function" && ("loadEntry" in config.loader || "loadCollection" in config.loader)) {
-    throw new AstroUserError(
-      `Live content collections must be defined in "src/live.config.ts" file. Check your collection definitions in "${importerFilename ?? "your content config file"}" to ensure you are not using a live loader.`
-    );
+  if ("loader" in config) {
+    if (config.type && config.type !== CONTENT_LAYER_TYPE) {
+      throw new AstroUserError(
+        `A content collection is defined with legacy features (e.g. missing a \`loader\` or has a \`type\`). Check your collection definitions in ${importerFilename ?? "your content config file"} to ensure that all collections are defined using the current properties.`
+      );
+    }
+    if (typeof config.loader === "object" && typeof config.loader.load !== "function" && ("loadEntry" in config.loader || "loadCollection" in config.loader)) {
+      throw new AstroUserError(
+        `Live content collections must be defined in "src/live.config.ts" file. Check the loaders used in "${importerFilename ?? "your content config file"}" to ensure you are not using a live loader to define a build-time content collection.`
+      );
+    }
+    config.type = CONTENT_LAYER_TYPE;
   }
-  config.type = CONTENT_LAYER_TYPE;
+  if (!config.type) config.type = "content";
   return config;
 }
 export {

package/dist/content/content-layer.js

@@ -133,14 +133,24 @@ class ContentLayer {
         )
       ]);
     }
-    if (contentConfig?.status === "error") {
-      logger.error(`Error loading content config. Skipping sync.
-${contentConfig.error.message}`);
-      return;
-    }
-    if (contentConfig?.status !== "loaded") {
-      logger.error(`Content config not loaded, skipping sync. Status was ${contentConfig?.status}`);
-      return;
+    switch (contentConfig?.status) {
+      case "loaded":
+        break;
+      case "error":
+        logger.error(
+          `Error loading content config. Skipping sync.
+${contentConfig.error.message}`
+        );
+        return;
+      case "does-not-exist":
+        return;
+      case "init":
+      case "loading":
+      case void 0:
+        logger.error(
+          `Content config not loaded, skipping sync. Status was ${contentConfig?.status}`
+        );
+        return;
     }
     logger.info("Syncing content");
     const {
@@ -164,7 +174,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.0.0-alpha.3") {
+    if (previousAstroVersion && previousAstroVersion !== "6.0.0-alpha.5") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -172,8 +182,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.0.0-alpha.3") {
-      await this.#store.metaStore().set("astro-version", "6.0.0-alpha.3");
+    if ("6.0.0-alpha.5") {
+      await this.#store.metaStore().set("astro-version", "6.0.0-alpha.5");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);
@@ -184,19 +194,24 @@ ${contentConfig.error.message}`);
     if (!options?.loaders?.length) {
       this.#watcher?.removeAllTrackedListeners();
     }
+    const backwardsCompatEnabled = this.#settings.config.legacy?.collectionsBackwardsCompat ?? false;
     await Promise.all(
       Object.entries(contentConfig.config.collections).map(async ([name, collection]) => {
-        if (collection.type !== CONTENT_LAYER_TYPE) {
+        if (collection.type !== CONTENT_LAYER_TYPE && !backwardsCompatEnabled) {
+          return;
+        }
+        if (collection.type !== CONTENT_LAYER_TYPE && !("loader" in collection)) {
           return;
         }
         let { schema } = collection;
-        if (!schema && typeof collection.loader === "object") {
+        const loaderName = "loader" in collection ? collection.loader.name : "content";
+        if (!schema && "loader" in collection && typeof collection.loader === "object") {
           schema = collection.loader.schema;
           if (!schema && collection.loader.createSchema) {
             ({ schema } = await collection.loader.createSchema());
           }
         }
-        if (options?.loaders && (typeof collection.loader !== "object" || !options.loaders.includes(collection.loader.name))) {
+        if (options?.loaders && "loader" in collection && (typeof collection.loader !== "object" || !options.loaders.includes(collection.loader.name))) {
           return;
         }
         const context = await this.#getLoaderContext({
@@ -214,16 +229,18 @@ ${contentConfig.error.message}`);
             { ...collection, schema },
             false
           ),
-          loaderName: collection.loader.name,
+          loaderName,
           refreshContextData: options?.context
         });
-        if (typeof collection.loader === "function") {
-          return simpleLoader(collection.loader, context);
-        }
-        if (!collection.loader.load) {
-          throw new Error(`Collection loader for ${name} does not have a load method`);
+        if ("loader" in collection) {
+          if (typeof collection.loader === "function") {
+            return simpleLoader(collection.loader, context);
+          }
+          if (!collection.loader?.load) {
+            throw new Error(`Collection loader for ${name} does not have a load method`);
+          }
+          return collection.loader.load(context);
         }
-        return collection.loader.load(context);
       })
     );
     await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });

package/dist/content/loaders/glob.d.ts

@@ -18,9 +18,12 @@ interface GlobOptions {
      **/
     generateId?: (options: GenerateIdOptions) => string;
 }
+export declare const secretLegacyFlag: unique symbol;
 /**
  * Loads multiple entries, using a glob pattern to match files.
  * @param pattern A glob pattern to match files, relative to the content directory.
  */
-export declare function glob(globOptions: GlobOptions): Loader;
+export declare function glob(globOptions: GlobOptions & {
+    [secretLegacyFlag]?: boolean;
+}): Loader;
 export {};

package/dist/content/loaders/glob.js

@@ -6,11 +6,19 @@ import colors from "piccolore";
 import picomatch from "picomatch";
 import { glob as tinyglobby } from "tinyglobby";
 import { getContentEntryIdAndSlug, posixRelative } from "../utils.js";
-function generateIdDefault({ entry, base, data }) {
+function generateIdDefault({ entry, base, data }, isLegacy) {
   if (data.slug) {
     return data.slug;
   }
   const entryURL = new URL(encodeURI(entry), base);
+  if (isLegacy) {
+    const { id } = getContentEntryIdAndSlug({
+      entry: entryURL,
+      contentDir: base,
+      collection: ""
+    });
+    return id;
+  }
   const { slug } = getContentEntryIdAndSlug({
     entry: entryURL,
     contentDir: base,
@@ -24,6 +32,7 @@ function checkPrefix(pattern, prefix) {
   }
   return pattern.startsWith(prefix);
 }
+const secretLegacyFlag = Symbol("astro.legacy-glob");
 function glob(globOptions) {
   if (checkPrefix(globOptions.pattern, "../")) {
     throw new Error(
@@ -35,11 +44,21 @@ function glob(globOptions) {
       "Glob patterns cannot start with `/`. Set the `base` option to a parent directory or use a relative path instead."
     );
   }
-  const generateId = globOptions?.generateId ?? generateIdDefault;
+  const isLegacy = !!globOptions[secretLegacyFlag];
+  const generateId = globOptions?.generateId ?? ((opts) => generateIdDefault(opts, isLegacy));
   const fileToIdMap = /* @__PURE__ */ new Map();
   return {
     name: "glob-loader",
-    load: async ({ config, logger, watcher, parseData, store, generateDigest, entryTypes }) => {
+    load: async ({
+      config,
+      collection,
+      logger,
+      watcher,
+      parseData,
+      store,
+      generateDigest,
+      entryTypes
+    }) => {
       const renderFunctionByContentType = /* @__PURE__ */ new WeakMap();
       const untouchedEntries = new Set(store.keys());
       async function syncData(entry, base, entryType, oldId) {
@@ -84,13 +103,16 @@ function glob(globOptions) {
           data,
           filePath: filePath2
         });
-        if (entryType.getRenderFunction) {
-          let render = renderFunctionByContentType.get(entryType);
-          if (store.has(id)) {
+        if (existingEntry && existingEntry.filePath && existingEntry.filePath !== relativePath2) {
+          const oldFilePath = new URL(existingEntry.filePath, config.root);
+          if (existsSync(oldFilePath)) {
             logger.warn(
               `Duplicate id "${id}" found in ${filePath2}. Later items with the same id will overwrite earlier ones.`
             );
           }
+        }
+        if (entryType.getRenderFunction) {
+          let render = renderFunctionByContentType.get(entryType);
           if (!render) {
             render = await entryType.getRenderFunction(config);
             renderFunctionByContentType.set(entryType, render);
@@ -130,7 +152,12 @@ function glob(globOptions) {
         }
         fileToIdMap.set(filePath2, id);
       }
-      const baseDir = globOptions.base ? new URL(globOptions.base, config.root) : config.root;
+      let baseDir;
+      if (isLegacy && !globOptions.base) {
+        baseDir = new URL(`./src/content/${collection}`, config.root);
+      } else {
+        baseDir = globOptions.base ? new URL(globOptions.base, config.root) : config.root;
+      }
       if (!baseDir.pathname.endsWith("/")) {
         baseDir.pathname = `${baseDir.pathname}/`;
       }
@@ -229,5 +256,6 @@ function glob(globOptions) {
   };
 }
 export {
-  glob
+  glob,
+  secretLegacyFlag
 };

package/dist/content/types-generator.js

@@ -35,7 +35,11 @@ async function createContentTypesGenerator({
   viteServer
 }) {
   const collectionEntryMap = {};
-  const contentPaths = getContentPaths(settings.config, fs);
+  const contentPaths = getContentPaths(
+    settings.config,
+    fs,
+    settings.config.legacy?.collectionsBackwardsCompat
+  );
   const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
   const contentEntryExts = [...contentEntryConfigByExt.keys()];
   const dataEntryExts = getDataEntryExts(settings);
@@ -288,10 +292,10 @@ async function typeForCollection(collection, collectionKey) {
   if (collection?.schema) {
     return { type: `InferEntrySchema<${collectionKey}>` };
   }
-  if (!collection?.type || typeof collection.loader === "function") {
+  if (!collection?.type || typeof collection.loader === "function" || !collection.loader) {
     return { type: "any" };
   }
-  if (collection.loader.schema) {
+  if (typeof collection.loader === "object" && collection.loader.schema) {
     return { type: `InferLoaderSchema<${collectionKey}>` };
   }
   const result = await getCreateSchemaResult(collection, collectionKey);
@@ -323,7 +327,7 @@ async function writeContentFiles({
   fs.mkdirSync(collectionSchemasDir, { recursive: true });
   for (const [collection, config] of Object.entries(contentConfig?.collections ?? {})) {
     collectionEntryMap[JSON.stringify(collection)] ??= {
-      type: config.type,
+      type: config.type ?? "unknown",
       entries: {}
     };
   }
@@ -388,8 +392,8 @@ async function writeContentFiles({
         hasSchema: Boolean(
           // Is there a user provided schema or
           collectionConfig?.schema || // Is it a loader object and
-          typeof collectionConfig?.loader !== "function" && // Is it a loader static schema or
-          (collectionConfig?.loader.schema || // is it a loader dynamic schema
+          typeof collectionConfig?.loader === "object" && // Is it a loader static schema or
+          (collectionConfig.loader.schema || // is it a loader dynamic schema
           createSchemaResultCache.has(collectionKey))
         ),
         name: key

package/dist/content/utils.d.ts

@@ -14,6 +14,14 @@ export declare const loaderReturnSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodOb
     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<{
@@ -38,6 +46,14 @@ declare const collectionConfigParser: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strip>]>;
 declare const contentConfigParser: z.ZodObject<{
     collections: z.ZodRecord<z.ZodString, 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<{
@@ -158,7 +174,7 @@ export type ContentPaths = {
         url: URL;
     };
 };
-export declare function getContentPaths({ srcDir, root }: Pick<AstroConfig, 'root' | 'srcDir'>, fs?: typeof fsMod): ContentPaths;
+export declare function getContentPaths({ srcDir, root }: Pick<AstroConfig, 'root' | 'srcDir'>, fs?: typeof fsMod, legacyCollectionsBackwardsCompat?: boolean): ContentPaths;
 /**
  * Check for slug in content entry frontmatter and validate the type,
  * falling back to the `generatedSlug` if none is found.

package/dist/content/utils.js

@@ -8,6 +8,7 @@ import xxhash from "xxhash-wasm";
 import * as z from "zod/v4";
 import { AstroError, AstroErrorData, errorMap, MarkdownError } from "../core/errors/index.js";
 import { isYAMLException } from "../core/errors/utils.js";
+import { appendForwardSlash } from "../core/path.js";
 import { normalizePath } from "../core/viteUtils.js";
 import {
   CONTENT_LAYER_TYPE,
@@ -17,6 +18,7 @@ import {
   LIVE_CONTENT_TYPE,
   PROPAGATED_ASSET_FLAG
 } from "./consts.js";
+import { glob, secretLegacyFlag } from "./loaders/glob.js";
 import { createImage } from "./runtime-assets.js";
 const entryTypeSchema = z.object({
   id: z.string({
@@ -36,6 +38,16 @@ const loaderReturnSchema = z.union([
   )
 ]);
 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(),
@@ -349,7 +361,11 @@ async function loadContentConfig({
   settings,
   environment
 }) {
-  const contentPaths = getContentPaths(settings.config, fs);
+  const contentPaths = getContentPaths(
+    settings.config,
+    fs,
+    settings.config.legacy?.collectionsBackwardsCompat
+  );
   if (!contentPaths.config.exists) {
     return void 0;
   }
@@ -383,6 +399,74 @@ ${message}
     return void 0;
   }
 }
+async function autogenerateCollections({
+  config,
+  settings,
+  fs
+}) {
+  if (!config) {
+    return config;
+  }
+  if (!settings.config.legacy?.collectionsBackwardsCompat) {
+    return config;
+  }
+  const contentDir = new URL("./content/", settings.config.srcDir);
+  const collections = config.collections ?? {};
+  const contentExts = getContentEntryExts(settings);
+  const dataExts = getDataEntryExts(settings);
+  const contentPattern = globWithUnderscoresIgnored("", contentExts);
+  const dataPattern = globWithUnderscoresIgnored("", dataExts);
+  let usesContentLayer = false;
+  for (const collectionName of Object.keys(collections)) {
+    const collection = collections[collectionName];
+    if (collection?.type === CONTENT_LAYER_TYPE || collection?.type === LIVE_CONTENT_TYPE) {
+      usesContentLayer = true;
+      continue;
+    }
+    const isDataCollection = collection?.type === "data";
+    const base = new URL(`${collectionName}/`, contentDir);
+    collections[collectionName] = {
+      ...collection,
+      type: CONTENT_LAYER_TYPE,
+      loader: glob({
+        base,
+        pattern: isDataCollection ? dataPattern : contentPattern,
+        [secretLegacyFlag]: true
+      })
+    };
+  }
+  if (!usesContentLayer && fs.existsSync(contentDir)) {
+    const orphanedCollections = [];
+    for (const entry of await fs.promises.readdir(contentDir, { withFileTypes: true })) {
+      const collectionName = entry.name;
+      if (["_", "."].includes(collectionName.at(0) ?? "")) {
+        continue;
+      }
+      if (entry.isDirectory() && !(collectionName in collections)) {
+        orphanedCollections.push(collectionName);
+        const base = new URL(`${collectionName}/`, contentDir);
+        collections[collectionName] = {
+          type: CONTENT_LAYER_TYPE,
+          loader: glob({
+            base,
+            pattern: contentPattern,
+            [secretLegacyFlag]: true
+          })
+        };
+      }
+    }
+    if (orphanedCollections.length > 0) {
+      console.warn(
+        `
+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".
+The following collections have been auto-generated: ${orphanedCollections.map((name) => colors.green(name)).join(", ")}
+`
+      );
+    }
+  }
+  return { ...config, collections };
+}
 async function reloadContentConfigObserver({
   observer = globalContentConfigObserver,
   ...loadContentConfigOpts
@@ -390,6 +474,10 @@ async function reloadContentConfigObserver({
   observer.set({ status: "loading" });
   try {
     let config = await loadContentConfig(loadContentConfigOpts);
+    config = await autogenerateCollections({
+      config,
+      ...loadContentConfigOpts
+    });
     if (config) {
       observer.set({ status: "loaded", config });
     } else {
@@ -424,20 +512,38 @@ function contentObservable(initialCtx) {
     subscribe
   };
 }
-function getContentPaths({ srcDir, root }, fs = fsMod) {
+function getContentPaths({ srcDir, root }, fs = fsMod, legacyCollectionsBackwardsCompat = false) {
+  const pkgBase = new URL("../../", import.meta.url);
   const configStats = searchConfig(fs, srcDir);
   if (!configStats.exists) {
     const legacyConfigStats = searchLegacyConfig(fs, srcDir);
     if (legacyConfigStats.exists) {
-      const relativePath = path.relative(fileURLToPath(root), fileURLToPath(legacyConfigStats.url));
-      throw new AstroError({
-        ...AstroErrorData.LegacyContentConfigError,
-        message: AstroErrorData.LegacyContentConfigError.message(relativePath)
-      });
+      if (!legacyCollectionsBackwardsCompat) {
+        const relativePath = path.relative(
+          fileURLToPath(root),
+          fileURLToPath(legacyConfigStats.url)
+        );
+        throw new AstroError({
+          ...AstroErrorData.LegacyContentConfigError,
+          message: AstroErrorData.LegacyContentConfigError.message(relativePath)
+        });
+      }
+      return getContentPathsWithConfig(root, srcDir, pkgBase, legacyConfigStats, fs);
     }
   }
   const liveConfigStats = searchLiveConfig(fs, srcDir);
-  const pkgBase = new URL("../../", import.meta.url);
+  return {
+    root: new URL("./", root),
+    contentDir: new URL("./content/", srcDir),
+    assetsDir: new URL("./assets/", srcDir),
+    typesTemplate: new URL("templates/content/types.d.ts", pkgBase),
+    virtualModTemplate: new URL("templates/content/module.mjs", pkgBase),
+    config: configStats,
+    liveConfig: liveConfigStats
+  };
+}
+function getContentPathsWithConfig(root, srcDir, pkgBase, configStats, fs) {
+  const liveConfigStats = searchLiveConfig(fs, srcDir);
   return {
     root: new URL("./", root),
     contentDir: new URL("./content/", srcDir),
@@ -499,6 +605,21 @@ async function getEntrySlug({
   });
   return parseEntrySlug({ generatedSlug, frontmatterSlug, id, collection });
 }
+function getExtGlob(exts) {
+  return exts.length === 1 ? (
+    // Wrapping {...} breaks when there is only one extension
+    exts[0]
+  ) : `{${exts.join(",")}}`;
+}
+function globWithUnderscoresIgnored(relContentDir, exts) {
+  const extGlob = getExtGlob(exts);
+  const contentDir = relContentDir.length > 0 ? appendForwardSlash(relContentDir) : relContentDir;
+  return [
+    `${contentDir}**/*${extGlob}`,
+    `!${contentDir}**/_*/**/*${extGlob}`,
+    `!${contentDir}**/_*${extGlob}`
+  ];
+}
 function hasAssetPropagationFlag(id) {
   try {
     return new URL(id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG);

package/dist/content/vite-plugin-content-assets.d.ts

@@ -1,6 +1,6 @@
-import type * as vite from 'vite';
 import { type Plugin } from 'vite';
 import type { BuildInternals } from '../core/build/internal.js';
+import type { ExtractedChunk } from '../core/build/static-build.js';
 import type { AstroSettings } from '../types/astro.js';
 export declare function astroContentAssetPropagationPlugin({ settings, }: {
     settings: AstroSettings;
@@ -10,8 +10,7 @@ export declare function astroContentAssetPropagationPlugin({ settings, }: {
  * Finds chunks with LINKS_PLACEHOLDER and STYLES_PLACEHOLDER, and replaces them
  * with actual styles from propagatedStylesMap.
  */
-export declare function contentAssetsBuildPostHook(base: string, internals: BuildInternals, { ssrOutputs, prerenderOutputs, mutate, }: {
-    ssrOutputs: vite.Rollup.RollupOutput[];
-    prerenderOutputs: vite.Rollup.RollupOutput[];
-    mutate: (chunk: vite.Rollup.OutputChunk, envs: ['server'], code: string) => void;
+export declare function contentAssetsBuildPostHook(base: string, internals: BuildInternals, { chunks, mutate, }: {
+    chunks: ExtractedChunk[];
+    mutate: (fileName: string, code: string, prerender: boolean) => void;
 }): Promise<void>;

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

@@ -148,17 +148,10 @@ async function getStylesForURL(filePath, environment) {
   };
 }
 async function contentAssetsBuildPostHook(base, internals, {
-  ssrOutputs,
-  prerenderOutputs,
+  chunks,
   mutate
 }) {
-  const outputs = ssrOutputs.flatMap((o) => o.output).concat(
-    ...(Array.isArray(prerenderOutputs) ? prerenderOutputs : [prerenderOutputs]).flatMap(
-      (o) => o.output
-    )
-  );
-  for (const chunk of outputs) {
-    if (chunk.type !== "chunk") continue;
+  for (const chunk of chunks) {
     if (!chunk.code.includes(LINKS_PLACEHOLDER)) continue;
     const entryStyles = /* @__PURE__ */ new Set();
     const entryLinks = /* @__PURE__ */ new Set();
@@ -189,7 +182,7 @@ async function contentAssetsBuildPostHook(base, internals, {
     } else {
       newCode = newCode.replace(JSON.stringify(LINKS_PLACEHOLDER), "[]");
     }
-    mutate(chunk, ["server"], newCode);
+    mutate(chunk.fileName, newCode, chunk.prerender);
   }
 }
 export {

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

@@ -40,7 +40,11 @@ function astroContentImportPlugin({
   settings,
   logger
 }) {
-  const contentPaths = getContentPaths(settings.config, fs);
+  const contentPaths = getContentPaths(
+    settings.config,
+    fs,
+    settings.config.legacy?.collectionsBackwardsCompat
+  );
   const contentEntryExts = getContentEntryExts(settings);
   const dataEntryExts = getDataEntryExts(settings);
   const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);

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

@@ -46,7 +46,11 @@ function astroContentVirtualModPlugin({
     enforce: "pre",
     config(_, env) {
       dataStoreFile = getDataStoreFile(settings, env.command === "serve");
-      const contentPaths = getContentPaths(settings.config);
+      const contentPaths = getContentPaths(
+        settings.config,
+        void 0,
+        settings.config.legacy?.collectionsBackwardsCompat
+      );
       if (contentPaths.liveConfig.exists) {
         liveConfig = normalizePath(fileURLToPath(contentPaths.liveConfig.url));
       }
@@ -178,7 +182,11 @@ async function generateContentEntryFile({
   settings,
   isClient
 }) {
-  const contentPaths = getContentPaths(settings.config);
+  const contentPaths = getContentPaths(
+    settings.config,
+    void 0,
+    settings.config.legacy?.collectionsBackwardsCompat
+  );
   const relContentDir = rootRelativePath(settings.config.root, contentPaths.contentDir);
   let virtualModContents;
   if (isClient) {

package/dist/core/build/plugins/plugin-manifest.d.ts

@@ -1,5 +1,4 @@
-import type { OutputChunk } from 'rollup';
-import type * as vite from 'vite';
+import type { ExtractedChunk } from '../static-build.js';
 import type { BuildInternals } from '../internal.js';
 import type { StaticBuildOptions } from '../types.js';
 /**
@@ -27,8 +26,7 @@ export declare const MANIFEST_REPLACE = "@@ASTRO_MANIFEST_REPLACE@@";
  * Post-build hook that injects the computed manifest into bundled chunks.
  * Finds the serialized manifest chunk and replaces the placeholder token with real data.
  */
-export declare function manifestBuildPostHook(options: StaticBuildOptions, internals: BuildInternals, { ssrOutputs, prerenderOutputs, mutate, }: {
-    ssrOutputs: vite.Rollup.RollupOutput[];
-    prerenderOutputs: vite.Rollup.RollupOutput[];
-    mutate: (chunk: OutputChunk, envs: ['server'], code: string) => void;
+export declare function manifestBuildPostHook(options: StaticBuildOptions, internals: BuildInternals, { chunks, mutate, }: {
+    chunks: ExtractedChunk[];
+    mutate: (fileName: string, code: string, prerender: boolean) => void;
 }): Promise<void>;

package/dist/core/build/plugins/plugin-manifest.js

@@ -29,30 +29,14 @@ import { sessionConfigToManifest } from "../../session/utils.js";
 const MANIFEST_REPLACE = "@@ASTRO_MANIFEST_REPLACE@@";
 const replaceExp = new RegExp(`['"]${MANIFEST_REPLACE}['"]`, "g");
 async function manifestBuildPostHook(options, internals, {
-  ssrOutputs,
-  prerenderOutputs,
+  chunks,
   mutate
 }) {
   const manifest = await createManifest(options, internals);
-  if (ssrOutputs.length > 0) {
-    let manifestEntryChunk;
-    for (const output of ssrOutputs) {
-      for (const chunk of output.output) {
-        if (chunk.type === "asset") {
-          continue;
-        }
-        if (chunk.code && chunk.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID)) {
-          manifestEntryChunk = chunk;
-          break;
-        }
-      }
-      if (manifestEntryChunk) {
-        break;
-      }
-    }
-    if (!manifestEntryChunk) {
-      throw new Error(`Did not find serialized manifest chunk for SSR`);
-    }
+  const ssrManifestChunk = chunks.find(
+    (c) => !c.prerender && c.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID)
+  );
+  if (ssrManifestChunk) {
     const shouldPassMiddlewareEntryPoint = options.settings.adapter?.adapterFeatures?.edgeMiddleware;
     await runHookBuildSsr({
       config: options.settings.config,
@@ -60,29 +44,15 @@ async function manifestBuildPostHook(options, internals, {
       logger: options.logger,
       middlewareEntryPoint: shouldPassMiddlewareEntryPoint ? internals.middlewareEntryPoint : void 0
     });
-    const code = injectManifest(manifest, manifestEntryChunk);
-    mutate(manifestEntryChunk, ["server"], code);
+    const code = injectManifest(manifest, ssrManifestChunk.code);
+    mutate(ssrManifestChunk.fileName, code, false);
   }
-  if (prerenderOutputs?.length > 0) {
-    let prerenderManifestChunk;
-    for (const output of prerenderOutputs) {
-      for (const chunk of output.output) {
-        if (chunk.type === "asset") {
-          continue;
-        }
-        if (chunk.code && chunk.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID)) {
-          prerenderManifestChunk = chunk;
-          break;
-        }
-      }
-      if (prerenderManifestChunk) {
-        break;
-      }
-    }
-    if (prerenderManifestChunk) {
-      const prerenderCode = injectManifest(manifest, prerenderManifestChunk);
-      mutate(prerenderManifestChunk, ["server"], prerenderCode);
-    }
+  const prerenderManifestChunk = chunks.find(
+    (c) => c.prerender && c.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID)
+  );
+  if (prerenderManifestChunk) {
+    const code = injectManifest(manifest, prerenderManifestChunk.code);
+    mutate(prerenderManifestChunk.fileName, code, true);
   }
 }
 async function createManifest(buildOpts, internals) {
@@ -99,8 +69,7 @@ async function createManifest(buildOpts, internals) {
   const manifest = await buildManifest(buildOpts, internals, Array.from(staticFiles), encodedKey);
   return manifest;
 }
-function injectManifest(manifest, chunk) {
-  const code = chunk.code;
+function injectManifest(manifest, code) {
   return code.replace(replaceExp, () => {
     return JSON.stringify(manifest);
   });

package/dist/core/build/static-build.d.ts

@@ -1,6 +1,16 @@
 import { type BuildInternals } from '../../core/build/internal.js';
 import type { RouteData } from '../../types/public/internal.js';
 import type { StaticBuildOptions } from './types.js';
+/**
+ * Minimal chunk data extracted from RollupOutput for deferred manifest/content injection.
+ * Allows releasing full RollupOutput objects early to reduce memory usage.
+ */
+export interface ExtractedChunk {
+    fileName: string;
+    code: string;
+    moduleIds: string[];
+    prerender: boolean;
+}
 export declare function viteBuild(opts: StaticBuildOptions): Promise<{
     internals: BuildInternals;
     prerenderOutputDir: URL;

package/dist/core/build/static-build.js

@@ -4,6 +4,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import colors from "piccolore";
 import { glob } from "tinyglobby";
 import * as vite from "vite";
+import { LINKS_PLACEHOLDER } from "../../content/consts.js";
 import { contentAssetsBuildPostHook } from "../../content/vite-plugin-content-assets.js";
 import { createBuildInternals } from "../../core/build/internal.js";
 import { emptyDir, removeEmptyDirs } from "../../core/fs/index.js";
@@ -27,6 +28,25 @@ import { encodeName, getTimeStat, viteBuildReturnToRollupOutputs } from "./util.
 import { NOOP_MODULE_ID } from "./plugins/plugin-noop.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
 const PRERENDER_ENTRY_FILENAME_PREFIX = "prerender-entry";
+function extractRelevantChunks(outputs, prerender) {
+  const extracted = [];
+  for (const output of outputs) {
+    for (const chunk of output.output) {
+      if (chunk.type === "asset") continue;
+      const needsContentInjection = chunk.code.includes(LINKS_PLACEHOLDER);
+      const needsManifestInjection = chunk.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID);
+      if (needsContentInjection || needsManifestInjection) {
+        extracted.push({
+          fileName: chunk.fileName,
+          code: chunk.code,
+          moduleIds: [...chunk.moduleIds],
+          prerender
+        });
+      }
+    }
+  }
+  return extracted;
+}
 async function viteBuild(opts) {
   const { allPages, settings } = opts;
   settings.timer.start("SSR build");
@@ -45,16 +65,13 @@ async function viteBuild(opts) {
   }
   const ssrTime = performance.now();
   opts.logger.info("build", `Building ${settings.buildOutput} entrypoints...`);
-  const { ssrOutput, prerenderOutput, clientOutput } = await buildEnvironments(opts, internals);
+  const { extractedChunks } = await buildEnvironments(opts, internals);
   opts.logger.info(
     "build",
     colors.green(`\u2713 Completed in ${getTimeStat(ssrTime, performance.now())}.`)
   );
   settings.timer.end("SSR build");
-  const ssrOutputs = viteBuildReturnToRollupOutputs(ssrOutput);
-  const clientOutputs = viteBuildReturnToRollupOutputs(clientOutput ?? []);
-  const prerenderOutputs = viteBuildReturnToRollupOutputs(prerenderOutput);
-  await runManifestInjection(opts, internals, ssrOutputs, clientOutputs, prerenderOutputs);
+  await runManifestInjection(opts, internals, extractedChunks);
   const prerenderOutputDir = new URL("./.prerender/", getServerOutputDirectory(settings));
   return { internals, prerenderOutputDir };
 }
@@ -208,16 +225,23 @@ async function buildEnvironments(opts, internals) {
     logger: opts.logger
   });
   const builder = await vite.createBuilder(updatedViteBuildConfig);
-  const ssrOutput = settings.buildOutput === "static" ? [] : await builder.build(builder.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]);
-  const prerenderOutput = await builder.build(builder.environments.prerender);
+  let ssrOutput = settings.buildOutput === "static" ? [] : await builder.build(builder.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]);
+  const ssrChunks = extractRelevantChunks(viteBuildReturnToRollupOutputs(ssrOutput), false);
+  ssrOutput = void 0;
+  let prerenderOutput = await builder.build(builder.environments.prerender);
   extractPrerenderEntryFileName(internals, prerenderOutput);
+  const prerenderChunks = extractRelevantChunks(
+    viteBuildReturnToRollupOutputs(prerenderOutput),
+    true
+  );
+  prerenderOutput = void 0;
   internals.clientInput = getClientInput(internals, settings);
   if (!internals.clientInput.size) {
     internals.clientInput.add(NOOP_MODULE_ID);
   }
   builder.environments.client.config.build.rollupOptions.input = Array.from(internals.clientInput);
-  const clientOutput = await builder.build(builder.environments.client);
-  return { ssrOutput, prerenderOutput, clientOutput };
+  await builder.build(builder.environments.client);
+  return { extractedChunks: [...ssrChunks, ...prerenderChunks] };
 }
 function getPrerenderEntryFileName(prerenderOutput) {
   const outputs = viteBuildReturnToRollupOutputs(prerenderOutput);
@@ -238,41 +262,25 @@ function getPrerenderEntryFileName(prerenderOutput) {
 function extractPrerenderEntryFileName(internals, prerenderOutput) {
   internals.prerenderEntryFileName = getPrerenderEntryFileName(prerenderOutput);
 }
-async function runManifestInjection(opts, internals, ssrOutputs, _clientOutputs, prerenderOutputs) {
+async function runManifestInjection(opts, internals, chunks) {
   const mutations = /* @__PURE__ */ new Map();
-  const mutate = (chunk, targets, newCode) => {
-    chunk.code = newCode;
-    mutations.set(chunk.fileName, {
-      targets,
-      code: newCode
-    });
+  const mutate = (fileName, newCode, prerender) => {
+    mutations.set(fileName, { code: newCode, prerender });
   };
-  await manifestBuildPostHook(opts, internals, {
-    ssrOutputs,
-    prerenderOutputs,
-    mutate
-  });
-  await contentAssetsBuildPostHook(opts.settings.config.base, internals, {
-    ssrOutputs,
-    prerenderOutputs,
-    mutate
-  });
-  await writeMutatedChunks(opts, mutations, prerenderOutputs);
+  await manifestBuildPostHook(opts, internals, { chunks, mutate });
+  await contentAssetsBuildPostHook(opts.settings.config.base, internals, { chunks, mutate });
+  await writeMutatedChunks(opts, mutations);
 }
-async function writeMutatedChunks(opts, mutations, prerenderOutputs) {
+async function writeMutatedChunks(opts, mutations) {
   const { settings } = opts;
   const config = settings.config;
-  const build = settings.config.build;
   const serverOutputDir = getServerOutputDirectory(settings);
   for (const [fileName, mutation] of mutations) {
     let root;
-    const isPrerender = prerenderOutputs.some(
-      (output) => output.output.some((chunk) => chunk.type !== "asset" && chunk.fileName === fileName)
-    );
-    if (isPrerender) {
+    if (mutation.prerender) {
       root = new URL("./.prerender/", serverOutputDir);
     } else if (settings.buildOutput === "server") {
-      root = mutation.targets.includes("server") ? build.server : build.client;
+      root = config.build.server;
     } else {
       root = getOutDirWithinCwd(config.outDir);
     }

package/dist/core/config/schemas/base.d.ts

@@ -57,7 +57,9 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
     integrations: never[];
     markdown: Required<import("@astrojs/markdown-remark").AstroMarkdownOptions>;
     vite: {};
-    legacy: {};
+    legacy: {
+        collectionsBackwardsCompat: false;
+    };
     redirects: {};
     security: {
         checkOrigin: true;
@@ -521,7 +523,9 @@ export declare const AstroConfigSchema: z.ZodObject<{
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         svgo: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCustom<SvgoConfig, SvgoConfig>]>>>;
     }, z.core.$strict>>;
-    legacy: z.ZodDefault<z.ZodObject<{}, z.core.$strip>>;
+    legacy: z.ZodPrefault<z.ZodObject<{
+        collectionsBackwardsCompat: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type AstroConfigType = z.infer<typeof AstroConfigSchema>;
 export {};

package/dist/core/config/schemas/base.js

@@ -41,7 +41,9 @@ const ASTRO_CONFIG_DEFAULTS = {
   integrations: [],
   markdown: markdownConfigDefaults,
   vite: {},
-  legacy: {},
+  legacy: {
+    collectionsBackwardsCompat: false
+  },
   redirects: {},
   security: {
     checkOrigin: true,
@@ -276,7 +278,9 @@ const AstroConfigSchema = z.object({
     chromeDevtoolsWorkspace: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.chromeDevtoolsWorkspace),
     svgo: z.union([z.boolean(), z.custom((value) => value && typeof value === "object")]).optional().default(ASTRO_CONFIG_DEFAULTS.experimental.svgo)
   }).prefault({}),
-  legacy: z.object({}).default({})
+  legacy: z.object({
+    collectionsBackwardsCompat: z.boolean().optional().default(false)
+  }).prefault({})
 });
 export {
   ASTRO_CONFIG_DEFAULTS,

package/dist/core/config/schemas/relative.d.ts

@@ -415,7 +415,9 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         svgo: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCustom<import("svgo").Config, import("svgo").Config>]>>>;
     }, z.core.$strict>>;
-    legacy: z.ZodDefault<z.ZodObject<{}, z.core.$strip>>;
+    legacy: z.ZodPrefault<z.ZodObject<{
+        collectionsBackwardsCompat: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>>;
     root: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<import("url").URL, string>>;
     srcDir: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<import("url").URL, string>>;
     compressHTML: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -633,7 +635,9 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             optimizedFallbacks?: boolean | undefined;
         })[] | undefined;
     };
-    legacy: Record<string, never>;
+    legacy: {
+        collectionsBackwardsCompat: boolean;
+    };
     root: import("url").URL;
     srcDir: import("url").URL;
     compressHTML: boolean;
@@ -890,7 +894,9 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             optimizedFallbacks?: boolean | undefined;
         })[] | undefined;
     };
-    legacy: Record<string, never>;
+    legacy: {
+        collectionsBackwardsCompat: boolean;
+    };
     root: import("url").URL;
     srcDir: import("url").URL;
     compressHTML: boolean;

package/dist/core/config/settings.js

@@ -17,7 +17,11 @@ import {
 import { AstroTimer } from "./timer.js";
 import { loadTSConfig } from "./tsconfig.js";
 function createBaseSettings(config, logLevel) {
-  const { contentDir } = getContentPaths(config);
+  const { contentDir } = getContentPaths(
+    config,
+    void 0,
+    config.legacy?.collectionsBackwardsCompat
+  );
   const dotAstroDir = new URL(".astro/", config.root);
   const preferences = createPreferences(config, dotAstroDir);
   return {

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.0.0-alpha.3";
+const ASTRO_VERSION = "6.0.0-alpha.5";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";

package/dist/core/dev/dev.js

@@ -22,7 +22,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "6.0.0-alpha.3";
+  const currentVersion = "6.0.0-alpha.5";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/errors/zod-error-map.js

@@ -11,7 +11,8 @@ const errorMap = (issue) => {
           typeOrLiteralErrByPath.set(flattenedErrorPath, {
             code: unionError.code,
             received: unionError.received,
-            expected: [unionError.expected]
+            expected: [unionError.expected],
+            message: unionError.message
           });
         }
       }
@@ -65,7 +66,8 @@ const errorMap = (issue) => {
         getTypeOrLiteralMsg({
           code: issue.code,
           received: typeof issue.input,
-          expected: [issue.expected]
+          expected: [issue.expected],
+          message: issue.message
         })
       )
     };
@@ -74,7 +76,8 @@ const errorMap = (issue) => {
   }
 };
 const getTypeOrLiteralMsg = (error) => {
-  if (typeof error.received === "undefined" || error.received === "undefined") return "Required";
+  if (typeof error.received === "undefined" || error.received === "undefined")
+    return error.message ?? "Required";
   const expectedDeduped = new Set(error.expected);
   switch (error.code) {
     case "invalid_type":

package/dist/core/messages.js

@@ -28,7 +28,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "6.0.0-alpha.3";
+  const version = "6.0.0-alpha.5";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -265,7 +265,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.0.0-alpha.3"}`
+        `v${"6.0.0-alpha.5"}`
       )} ${headline}`
     );
   }

package/dist/core/sync/index.js

@@ -109,7 +109,11 @@ async function syncInternal({
     }
     settings.timer.end("Sync content layer");
   } else {
-    const paths = getContentPaths(settings.config, fs);
+    const paths = getContentPaths(
+      settings.config,
+      fs,
+      settings.config.legacy?.collectionsBackwardsCompat
+    );
     if (paths.config.exists || paths.liveConfig.exists) {
       settings.injectedTypes.push({
         filename: CONTENT_TYPES_FILE
@@ -210,7 +214,11 @@ async function syncContentCollections(settings, { mode, logger, fs }) {
     }
     let configFile;
     try {
-      const contentPaths = getContentPaths(settings.config, fs);
+      const contentPaths = getContentPaths(
+        settings.config,
+        fs,
+        settings.config.legacy?.collectionsBackwardsCompat
+      );
       if (contentPaths.config.exists) {
         const matches = /\/(src\/.+)/.exec(contentPaths.config.url.href);
         if (matches) {

package/dist/types/public/config.d.ts

@@ -2249,7 +2249,25 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      * These flags allow you to opt in to some deprecated or otherwise outdated behavior of Astro
      * in the latest version, so that you can continue to upgrade and take advantage of new Astro releases.
      */
-    legacy?: Record<string, never>;
+    legacy?: {
+        /**
+         * Enable backwards compatibility for v4 content collections.
+         *
+         * When enabled, restores the following v4 behaviors:
+         * - Allows legacy config file location: `src/content/config.ts`
+         * - Allows collections without explicit loaders (automatically wraps with glob loader)
+         * - Supports `type: 'content'` and `type: 'data'` without loaders
+         * - Preserves legacy entry API: `entry.slug` and `entry.render()`
+         * - Uses path-based entry IDs instead of slug-based IDs
+         *
+         * This is a temporary migration helper for projects upgrading to v6.
+         * Migrate collections to the Content Layer API, then disable this flag.
+         *
+         * @type {boolean}
+         * @default false
+         */
+        collectionsBackwardsCompat?: boolean;
+    };
     /**
      *
      * @kind heading

package/dist/vite-plugin-config-alias/index.js

@@ -46,7 +46,7 @@ const getViteResolveAlias = (settings) => {
         for (const resolvedValue of resolvedValues) {
           const resolved = resolvedValue.replace("*", id);
           if (fs.existsSync(resolved)) {
-            return resolved;
+            return normalizePath(resolved);
           }
         }
         return null;

package/dist/vite-plugin-pages/pages.js

@@ -5,6 +5,18 @@ import { getVirtualModulePageName } from "./util.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 const VIRTUAL_PAGES_MODULE_ID = "virtual:astro:pages";
 const VIRTUAL_PAGES_RESOLVED_MODULE_ID = "\0" + VIRTUAL_PAGES_MODULE_ID;
+function getRoutesForEnvironment(routes, isPrerender) {
+  const result = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    if (route.prerender === isPrerender) {
+      result.add(route);
+    }
+    if (route.redirectRoute) {
+      result.add(route.redirectRoute);
+    }
+  }
+  return result;
+}
 function pluginPages({ routesList }) {
   return {
     name: "@astro/plugin-pages",
@@ -28,7 +40,11 @@ function pluginPages({ routesList }) {
         const imports = [];
         const pageMap = [];
         let i = 0;
-        for (const route of routesList.routes) {
+        const envName = this.environment.name;
+        const isSSR = envName === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
+        const isPrerender = envName === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+        const routes = isSSR || isPrerender ? getRoutesForEnvironment(routesList.routes, isPrerender) : new Set(routesList.routes);
+        for (const route of routes) {
           if (routeIsRedirect(route)) {
             continue;
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.0.0-alpha.3",
+  "version": "6.0.0-alpha.5",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -194,8 +194,8 @@
     "undici": "^6.22.0",
     "unified": "^11.0.5",
     "vitest": "^3.2.4",
-    "@astrojs/check": "0.9.6-alpha.0",
-    "astro-scripts": "0.0.14"
+    "astro-scripts": "0.0.14",
+    "@astrojs/check": "0.9.6-alpha.0"
   },
   "engines": {
     "node": "^20.19.5 || >=22.12.0",