astro 6.0.0-alpha.4 → 6.0.0-beta.0

package/dist/assets/utils/vendor/image-size/types/utils.js

@@ -1,44 +1,45 @@
 const decoder = new TextDecoder();
 const toUTF8String = (input, start = 0, end = input.length) => decoder.decode(input.slice(start, end));
-const toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i) => memo + ("0" + i.toString(16)).slice(-2), "");
-const readInt16LE = (input, offset = 0) => {
-  const val = input[offset] + input[offset + 1] * 2 ** 8;
-  return val | (val & 2 ** 15) * 131070;
+const toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i) => memo + `0${i.toString(16)}`.slice(-2), "");
+const getView = (input, offset) => new DataView(input.buffer, input.byteOffset + offset);
+const readInt16LE = (input, offset = 0) => getView(input, offset).getInt16(0, true);
+const readUInt16BE = (input, offset = 0) => getView(input, offset).getUint16(0, false);
+const readUInt16LE = (input, offset = 0) => getView(input, offset).getUint16(0, true);
+const readUInt24LE = (input, offset = 0) => {
+  const view = getView(input, offset);
+  return view.getUint16(0, true) + (view.getUint8(2) << 16);
 };
-const readUInt16BE = (input, offset = 0) => input[offset] * 2 ** 8 + input[offset + 1];
-const readUInt16LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8;
-const readUInt24LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8 + input[offset + 2] * 2 ** 16;
-const readInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8 + input[offset + 2] * 2 ** 16 + (input[offset + 3] << 24);
-const readUInt32BE = (input, offset = 0) => input[offset] * 2 ** 24 + input[offset + 1] * 2 ** 16 + input[offset + 2] * 2 ** 8 + input[offset + 3];
-const readUInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8 + input[offset + 2] * 2 ** 16 + input[offset + 3] * 2 ** 24;
+const readInt32LE = (input, offset = 0) => getView(input, offset).getInt32(0, true);
+const readUInt32BE = (input, offset = 0) => getView(input, offset).getUint32(0, false);
+const readUInt32LE = (input, offset = 0) => getView(input, offset).getUint32(0, true);
+const readUInt64 = (input, offset, isBigEndian) => getView(input, offset).getBigUint64(0, !isBigEndian);
 const methods = {
   readUInt16BE,
   readUInt16LE,
   readUInt32BE,
   readUInt32LE
 };
-function readUInt(input, bits, offset, isBigEndian) {
-  offset = offset || 0;
+function readUInt(input, bits, offset = 0, isBigEndian = false) {
   const endian = isBigEndian ? "BE" : "LE";
-  const methodName = "readUInt" + bits + endian;
+  const methodName = `readUInt${bits}${endian}`;
   return methods[methodName](input, offset);
 }
-function readBox(buffer, offset) {
-  if (buffer.length - offset < 4) return;
-  const boxSize = readUInt32BE(buffer, offset);
-  if (buffer.length - offset < boxSize) return;
+function readBox(input, offset) {
+  if (input.length - offset < 4) return;
+  const boxSize = readUInt32BE(input, offset);
+  if (input.length - offset < boxSize) return;
   return {
-    name: toUTF8String(buffer, 4 + offset, 8 + offset),
+    name: toUTF8String(input, 4 + offset, 8 + offset),
     offset,
     size: boxSize
   };
 }
-function findBox(buffer, boxName, offset) {
-  while (offset < buffer.length) {
-    const box = readBox(buffer, offset);
+function findBox(input, boxName, currentOffset) {
+  while (currentOffset < input.length) {
+    const box = readBox(input, currentOffset);
     if (!box) break;
     if (box.name === boxName) return box;
-    offset += box.size;
+    currentOffset += box.size > 0 ? box.size : 8;
   }
 }
 export {
@@ -51,6 +52,7 @@ export {
   readUInt24LE,
   readUInt32BE,
   readUInt32LE,
+  readUInt64,
   toHexString,
   toUTF8String
 };

package/dist/assets/utils/vendor/image-size/types/webp.js

@@ -1,4 +1,4 @@
-import { toHexString, toUTF8String, readInt16LE, readUInt24LE } from "./utils.js";
+import { readInt16LE, readUInt24LE, toHexString, toUTF8String } from "./utils.js";
 function calculateExtended(input) {
   return {
     height: 1 + readUInt24LE(input, 7),
@@ -24,18 +24,17 @@ const WEBP = {
     const vp8Header = "VP8" === toUTF8String(input, 12, 15);
     return riffHeader && webpHeader && vp8Header;
   },
-  calculate(input) {
-    const chunkHeader = toUTF8String(input, 12, 16);
-    input = input.slice(20, 30);
+  calculate(_input) {
+    const chunkHeader = toUTF8String(_input, 12, 16);
+    const input = _input.slice(20, 30);
     if (chunkHeader === "VP8X") {
       const extendedHeader = input[0];
       const validStart = (extendedHeader & 192) === 0;
       const validEnd = (extendedHeader & 1) === 0;
       if (validStart && validEnd) {
         return calculateExtended(input);
-      } else {
-        throw new TypeError("Invalid WebP");
       }
+      throw new TypeError("Invalid WebP");
     }
     if (chunkHeader === "VP8 " && input[0] !== 47) {
       return calculateLossy(input);

package/dist/assets/utils/vendor/image-size/utils/bit-reader.d.ts

@@ -0,0 +1,10 @@
+/** This class helps read Uint8Array bit-by-bit */
+export declare class BitReader {
+    private readonly input;
+    private readonly endianness;
+    private byteOffset;
+    private bitOffset;
+    constructor(input: Uint8Array, endianness: 'big-endian' | 'little-endian');
+    /** Reads a specified number of bits, and move the offset */
+    getBits(length?: number): number;
+}

package/dist/assets/utils/vendor/image-size/utils/bit-reader.js

@@ -0,0 +1,41 @@
+class BitReader {
+  constructor(input, endianness) {
+    this.input = input;
+    this.endianness = endianness;
+  }
+  // Skip the first 16 bits (2 bytes) of signature
+  byteOffset = 2;
+  bitOffset = 0;
+  /** Reads a specified number of bits, and move the offset */
+  getBits(length = 1) {
+    let result = 0;
+    let bitsRead = 0;
+    while (bitsRead < length) {
+      if (this.byteOffset >= this.input.length) {
+        throw new Error("Reached end of input");
+      }
+      const currentByte = this.input[this.byteOffset];
+      const bitsLeft = 8 - this.bitOffset;
+      const bitsToRead = Math.min(length - bitsRead, bitsLeft);
+      if (this.endianness === "little-endian") {
+        const mask = (1 << bitsToRead) - 1;
+        const bits = currentByte >> this.bitOffset & mask;
+        result |= bits << bitsRead;
+      } else {
+        const mask = (1 << bitsToRead) - 1 << 8 - this.bitOffset - bitsToRead;
+        const bits = (currentByte & mask) >> 8 - this.bitOffset - bitsToRead;
+        result = result << bitsToRead | bits;
+      }
+      bitsRead += bitsToRead;
+      this.bitOffset += bitsToRead;
+      if (this.bitOffset === 8) {
+        this.byteOffset++;
+        this.bitOffset = 0;
+      }
+    }
+    return result;
+  }
+}
+export {
+  BitReader
+};

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

@@ -121,6 +121,13 @@ function assets({ fs, settings, sync, logger }) {
 							export { default as Font } from "astro/components/Font.astro";
 							import * as fontsMod from 'virtual:astro:assets/fonts/internal';
 							import { createGetFontData } from "astro/assets/fonts/runtime";
+							
+							export const viteFSConfig = ${JSON.stringify(resolvedConfig.server.fs)} ?? {};
+
+							export const safeModulePaths = new Set(${JSON.stringify(
+              // @ts-expect-error safeModulePaths is internal to Vite
+              Array.from(resolvedConfig.safeModulePaths)
+            )} ?? []);
 
 							const assetQueryParams = ${settings.adapter?.client?.assetQueryParams ? `new URLSearchParams(${JSON.stringify(
               Array.from(settings.adapter.client.assetQueryParams.entries())

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.4";
+  version = "6.0.0-beta.0";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/config/entrypoint.d.ts

@@ -1,7 +1,6 @@
 import type { SharpImageServiceConfig } from '../assets/services/sharp.js';
 import type { ImageServiceConfig } from '../types/public/index.js';
-export { defineAstroFontProvider, fontProviders } from '../assets/fonts/providers/index.js';
-export type { AstroFontProvider } from '../assets/fonts/types.js';
+export { fontProviders } from '../assets/fonts/providers/index.js';
 export { mergeConfig } from '../core/config/merge.js';
 export { validateConfig } from '../core/config/validate.js';
 export { envField } from '../env/config.js';

package/dist/config/entrypoint.js

@@ -1,4 +1,4 @@
-import { defineAstroFontProvider, fontProviders } from "../assets/fonts/providers/index.js";
+import { fontProviders } from "../assets/fonts/providers/index.js";
 import { mergeConfig } from "../core/config/merge.js";
 import { validateConfig } from "../core/config/validate.js";
 import { envField } from "../env/config.js";
@@ -17,7 +17,6 @@ function passthroughImageService() {
   };
 }
 export {
-  defineAstroFontProvider,
   defineConfig,
   envField,
   fontProviders,

package/dist/config/index.js

@@ -1,4 +1,4 @@
-import { createRoutesList } from "../core/routing/index.js";
+import { createRoutesList } from "../core/routing/manifest/create.js";
 function defineConfig(config) {
   return config;
 }

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.4") {
+    if (previousAstroVersion && previousAstroVersion !== "6.0.0-beta.0") {
       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.4") {
-      await this.#store.metaStore().set("astro-version", "6.0.0-alpha.4");
+    if ("6.0.0-beta.0") {
+      await this.#store.metaStore().set("astro-version", "6.0.0-beta.0");
     }
     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.