astro 6.0.0-alpha.0 → 6.0.0-alpha.2

package/dist/content/types-generator.js

@@ -1,9 +1,11 @@
 import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import colors from "picocolors";
-import { normalizePath } from "vite";
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import colors from "piccolore";
+import {
+  isRunnableDevEnvironment,
+  normalizePath
+} from "vite";
+import * as z from "zod/v4";
 import { AstroError } from "../core/errors/errors.js";
 import { AstroErrorData } from "../core/errors/index.js";
 import { isRelativePath } from "../core/path.js";
@@ -24,6 +26,7 @@ import {
   getEntryType,
   reloadContentConfigObserver
 } from "./utils.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 async function createContentTypesGenerator({
   contentConfigObserver,
   fs,
@@ -75,7 +78,11 @@ async function createContentTypesGenerator({
       return { shouldGenerateTypes: false };
     }
     if (fileType === "config") {
-      await reloadContentConfigObserver({ fs, settings, viteServer });
+      await reloadContentConfigObserver({
+        fs,
+        settings,
+        environment: viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro]
+      });
       return { shouldGenerateTypes: true };
     }
     const { entry } = event;
@@ -103,7 +110,7 @@ async function createContentTypesGenerator({
           }
           const collectionInfo2 = collectionEntryMap[collectionKey2];
           if (collectionInfo2.type === "content") {
-            viteServer.hot.send({
+            viteServer.environments.client.hot.send({
               type: "error",
               err: new AstroError({
                 ...AstroErrorData.MixedContentDataCollectionError,
@@ -142,7 +149,7 @@ async function createContentTypesGenerator({
     }
     const collectionInfo = collectionEntryMap[collectionKey];
     if (collectionInfo.type === "data") {
-      viteServer.hot.send({
+      viteServer.environments.client.hot.send({
         type: "error",
         err: new AstroError({
           ...AstroErrorData.MixedContentDataCollectionError,
@@ -237,59 +244,68 @@ async function createContentTypesGenerator({
         logger,
         settings
       });
-      invalidateVirtualMod(viteServer);
+      if (!isRunnableDevEnvironment(viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr])) {
+        return;
+      }
+      invalidateVirtualMod(viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]);
     }
   }
   return { init, queueEvent };
 }
-function invalidateVirtualMod(viteServer) {
-  const virtualMod = viteServer.moduleGraph.getModuleById("\0" + VIRTUAL_MODULE_ID);
+function invalidateVirtualMod(environment) {
+  const virtualMod = environment.moduleGraph.getModuleById("\0" + VIRTUAL_MODULE_ID);
   if (!virtualMod) return;
-  viteServer.moduleGraph.invalidateModule(virtualMod);
+  environment.moduleGraph.invalidateModule(virtualMod);
 }
 function normalizeConfigPath(from, to) {
   const configPath = path.relative(from, to).replace(/\.ts$/, ".js");
   const normalizedPath = configPath.replaceAll("\\", "/");
   return `"${isRelativePath(configPath) ? "" : "./"}${normalizedPath}"`;
 }
-const schemaCache = /* @__PURE__ */ new Map();
-async function getContentLayerSchema(collection, collectionKey) {
-  const cached = schemaCache.get(collectionKey);
+const createSchemaResultCache = /* @__PURE__ */ new Map();
+async function getCreateSchemaResult(collection, collectionKey) {
+  const cached = createSchemaResultCache.get(collectionKey);
   if (cached) {
     return cached;
   }
-  if (collection?.type === CONTENT_LAYER_TYPE && typeof collection.loader === "object" && collection.loader.schema) {
-    let schema = collection.loader.schema;
-    if (typeof schema === "function") {
-      schema = await schema();
-    }
-    if (schema) {
-      schemaCache.set(collectionKey, await schema);
-      return schema;
-    }
+  if (collection?.type === CONTENT_LAYER_TYPE && typeof collection.loader === "object" && !collection.loader.schema && collection.loader.createSchema) {
+    const result = await collection.loader.createSchema();
+    createSchemaResultCache.set(collectionKey, result);
+    return result;
+  }
+}
+async function getContentLayerSchema(collection, collectionKey) {
+  if (collection?.type !== CONTENT_LAYER_TYPE || typeof collection.loader === "function") {
+    return;
+  }
+  if (collection.loader.schema) {
+    return collection.loader.schema;
   }
+  const result = await getCreateSchemaResult(collection, collectionKey);
+  return result?.schema;
 }
 async function typeForCollection(collection, collectionKey) {
   if (collection?.schema) {
-    return `InferEntrySchema<${collectionKey}>`;
+    return { type: `InferEntrySchema<${collectionKey}>` };
   }
-  if (!collection?.type) {
-    return "any";
+  if (!collection?.type || typeof collection.loader === "function") {
+    return { type: "any" };
   }
-  const schema = await getContentLayerSchema(collection, collectionKey);
-  if (!schema) {
-    return "any";
+  if (collection.loader.schema) {
+    return { type: `InferLoaderSchema<${collectionKey}>` };
   }
-  try {
-    const zodToTs = await import("zod-to-ts");
-    const ast = zodToTs.zodToTs(schema);
-    return zodToTs.printNode(ast.node);
-  } catch (err) {
-    if (err.message.includes("Cannot find package 'typescript'")) {
-      return "any";
-    }
-    throw err;
+  const result = await getCreateSchemaResult(collection, collectionKey);
+  if (!result) {
+    return { type: "any" };
   }
+  const base = `loaders/${collectionKey.slice(1, -1)}`;
+  return {
+    type: `import("./${base}.js").Entry`,
+    injectedType: {
+      filename: `${base}.ts`,
+      content: result.types
+    }
+  };
 }
 async function writeContentFiles({
   fs,
@@ -316,7 +332,7 @@ async function writeContentFiles({
     const collectionConfig = contentConfig?.collections[JSON.parse(collectionKey)];
     const collection = collectionEntryMap[collectionKey];
     if (collectionConfig?.type && collection.type !== "unknown" && collectionConfig.type !== CONTENT_LAYER_TYPE && collection.type !== collectionConfig.type) {
-      viteServer.hot.send({
+      viteServer.environments.client.hot.send({
         type: "error",
         err: new AstroError({
           ...AstroErrorData.ContentCollectionTypeMismatchError,
@@ -333,7 +349,19 @@ async function writeContentFiles({
       });
       return;
     }
-    const dataType = await typeForCollection(collectionConfig, collectionKey);
+    const { type: dataType, injectedType } = await typeForCollection(
+      collectionConfig,
+      collectionKey
+    );
+    if (injectedType) {
+      if (settings.injectedTypes.some((t) => t.filename === CONTENT_TYPES_FILE)) {
+        const url = new URL(injectedType.filename, settings.dotAstroDir);
+        await fs.promises.mkdir(path.dirname(fileURLToPath(url)), { recursive: true });
+        await fs.promises.writeFile(url, injectedType.content, "utf-8");
+      } else {
+        settings.injectedTypes.push(injectedType);
+      }
+    }
     dataTypesStr += `${collectionKey}: Record<string, {
   id: string;
   body?: string;
@@ -357,7 +385,13 @@ async function writeContentFiles({
       const collectionConfig = contentConfig?.collections[JSON.parse(collectionKey)];
       const key = JSON.parse(collectionKey);
       contentCollectionManifest.collections.push({
-        hasSchema: Boolean(collectionConfig?.schema || schemaCache.has(collectionKey)),
+        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
+          createSchemaResultCache.has(collectionKey))
+        ),
         name: key
       });
       Object.keys(collection.entries).forEach((entryKey) => {
@@ -417,20 +451,22 @@ async function generateJSONSchema(fsMod, collectionConfig, collectionKey, collec
     });
   }
   try {
-    await fsMod.promises.writeFile(
-      new URL(`./${collectionKey.replace(/"/g, "")}.schema.json`, collectionSchemasDir),
-      JSON.stringify(
-        zodToJsonSchema(zodSchemaForJson, {
-          name: collectionKey.replace(/"/g, ""),
-          markdownDescription: true,
-          errorMessages: true,
-          // Fix for https://github.com/StefanTerdell/zod-to-json-schema/issues/110
-          dateStrategy: ["format:date-time", "format:date", "integer"]
-        }),
-        null,
-        2
-      )
+    const schema = z.toJSONSchema(zodSchemaForJson, {
+      unrepresentable: "any",
+      override: (ctx) => {
+        const def = ctx.zodSchema._zod.def;
+        if (def.type === "date") {
+          ctx.jsonSchema.type = "string";
+          ctx.jsonSchema.format = "date-time";
+        }
+      }
+    });
+    const schemaStr = JSON.stringify(schema, null, 2);
+    const schemaJsonPath = new URL(
+      `./${collectionKey.replace(/"/g, "")}.schema.json`,
+      collectionSchemasDir
     );
+    await fsMod.promises.writeFile(schemaJsonPath, schemaStr);
   } catch (err) {
     logger.warn(
       "content",

package/dist/content/utils.d.ts

@@ -1,349 +1,66 @@
 import fsMod from 'node:fs';
 import type { PluginContext } from 'rollup';
-import type { ViteDevServer } from 'vite';
-import { z } from 'zod';
+import type { RunnableDevEnvironment } from 'vite';
+import * as z from 'zod/v4';
 import type { Logger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
 import type { AstroConfig } from '../types/public/config.js';
 import type { ContentEntryType, DataEntryType } from '../types/public/content.js';
 import { type CONTENT_FLAGS } from './consts.js';
-export declare const loaderReturnSchema: z.ZodUnion<[z.ZodArray<z.ZodObject<{
+import type { LoaderContext } from './loaders/types.js';
+export declare const loaderReturnSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
     id: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    id: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    id: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>, "many">, z.ZodRecord<z.ZodString, z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+}, z.core.$loose>>, z.ZodRecord<z.ZodString, z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    id: z.ZodOptional<z.ZodString>;
-}, z.ZodTypeAny, "passthrough">>>]>;
-declare const collectionConfigParser: z.ZodUnion<[z.ZodObject<{
+}, z.core.$loose>>]>;
+declare const collectionConfigParser: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"content_layer">;
     schema: z.ZodOptional<z.ZodAny>;
-    loader: z.ZodUnion<[z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>, z.ZodObject<{
+    loader: z.ZodUnion<readonly [z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>, z.ZodObject<{
         name: z.ZodString;
-        load: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
-            collection: z.ZodString;
-            store: z.ZodAny;
-            meta: z.ZodAny;
-            logger: z.ZodAny;
-            config: z.ZodAny;
-            entryTypes: z.ZodAny;
-            parseData: z.ZodAny;
-            renderMarkdown: z.ZodAny;
-            generateDigest: z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>;
-            watcher: z.ZodOptional<z.ZodAny>;
-            refreshContextData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, "strip", z.ZodTypeAny, {
-            collection: string;
-            generateDigest: (args_0: any) => unknown;
-            config?: any;
-            meta?: any;
-            logger?: any;
-            store?: any;
-            entryTypes?: any;
-            parseData?: any;
-            renderMarkdown?: any;
-            watcher?: any;
-            refreshContextData?: Record<string, unknown> | undefined;
-        }, {
-            collection: string;
-            generateDigest: (args_0: any) => unknown;
-            config?: any;
-            meta?: any;
-            logger?: any;
-            store?: any;
-            entryTypes?: any;
-            parseData?: any;
-            renderMarkdown?: any;
-            watcher?: any;
-            refreshContextData?: Record<string, unknown> | undefined;
-        }>], null>, z.ZodUnknown>;
-        schema: z.ZodOptional<z.ZodAny>;
-        render: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        load: (args_0: {
-            collection: string;
-            generateDigest: (args_0: any) => unknown;
-            config?: any;
-            meta?: any;
-            logger?: any;
-            store?: any;
-            entryTypes?: any;
-            parseData?: any;
-            renderMarkdown?: any;
-            watcher?: any;
-            refreshContextData?: Record<string, unknown> | undefined;
-        }) => unknown;
-        schema?: any;
-        render?: ((args_0: any) => unknown) | undefined;
-    }, {
-        name: string;
-        load: (args_0: {
-            collection: string;
-            generateDigest: (args_0: any) => unknown;
-            config?: any;
-            meta?: any;
-            logger?: any;
-            store?: any;
-            entryTypes?: any;
-            parseData?: any;
-            renderMarkdown?: any;
-            watcher?: any;
-            refreshContextData?: Record<string, unknown> | undefined;
-        }) => unknown;
-        schema?: any;
-        render?: ((args_0: any) => unknown) | undefined;
-    }>]>;
-}, "strip", z.ZodTypeAny, {
-    type: "content_layer";
-    loader: ((...args: unknown[]) => unknown) | {
-        name: string;
-        load: (args_0: {
-            collection: string;
-            generateDigest: (args_0: any) => unknown;
-            config?: any;
-            meta?: any;
-            logger?: any;
-            store?: any;
-            entryTypes?: any;
-            parseData?: any;
-            renderMarkdown?: any;
-            watcher?: any;
-            refreshContextData?: Record<string, unknown> | undefined;
-        }) => unknown;
-        schema?: any;
-        render?: ((args_0: any) => unknown) | undefined;
-    };
-    schema?: any;
-}, {
-    type: "content_layer";
-    loader: ((...args: unknown[]) => unknown) | {
-        name: string;
-        load: (args_0: {
-            collection: string;
-            generateDigest: (args_0: any) => unknown;
-            config?: any;
-            meta?: any;
-            logger?: any;
-            store?: any;
-            entryTypes?: any;
-            parseData?: any;
-            renderMarkdown?: any;
-            watcher?: any;
-            refreshContextData?: Record<string, unknown> | undefined;
-        }) => unknown;
-        schema?: any;
-        render?: ((args_0: any) => unknown) | undefined;
-    };
-    schema?: any;
-}>, z.ZodObject<{
+        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.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-}, "strip", z.ZodTypeAny, {
-    type: "live";
-    loader: (...args: unknown[]) => unknown;
-    schema?: any;
-}, {
-    loader: (...args: unknown[]) => unknown;
-    type?: "live" | undefined;
-    schema?: any;
-}>]>;
+    loader: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+}, z.core.$strip>]>;
 declare const contentConfigParser: z.ZodObject<{
-    collections: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    collections: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"content_layer">;
         schema: z.ZodOptional<z.ZodAny>;
-        loader: z.ZodUnion<[z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>, z.ZodObject<{
+        loader: z.ZodUnion<readonly [z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>, z.ZodObject<{
             name: z.ZodString;
-            load: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
-                collection: z.ZodString;
-                store: z.ZodAny;
-                meta: z.ZodAny;
-                logger: z.ZodAny;
-                config: z.ZodAny;
-                entryTypes: z.ZodAny;
-                parseData: z.ZodAny;
-                renderMarkdown: z.ZodAny;
-                generateDigest: z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>;
-                watcher: z.ZodOptional<z.ZodAny>;
-                refreshContextData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, "strip", z.ZodTypeAny, {
-                collection: string;
-                generateDigest: (args_0: any) => unknown;
-                config?: any;
-                meta?: any;
-                logger?: any;
-                store?: any;
-                entryTypes?: any;
-                parseData?: any;
-                renderMarkdown?: any;
-                watcher?: any;
-                refreshContextData?: Record<string, unknown> | undefined;
-            }, {
-                collection: string;
-                generateDigest: (args_0: any) => unknown;
-                config?: any;
-                meta?: any;
-                logger?: any;
-                store?: any;
-                entryTypes?: any;
-                parseData?: any;
-                renderMarkdown?: any;
-                watcher?: any;
-                refreshContextData?: Record<string, unknown> | undefined;
-            }>], null>, z.ZodUnknown>;
-            schema: z.ZodOptional<z.ZodAny>;
-            render: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>>;
-        }, "strip", z.ZodTypeAny, {
-            name: string;
-            load: (args_0: {
-                collection: string;
-                generateDigest: (args_0: any) => unknown;
-                config?: any;
-                meta?: any;
-                logger?: any;
-                store?: any;
-                entryTypes?: any;
-                parseData?: any;
-                renderMarkdown?: any;
-                watcher?: any;
-                refreshContextData?: Record<string, unknown> | undefined;
-            }) => unknown;
-            schema?: any;
-            render?: ((args_0: any) => unknown) | undefined;
-        }, {
-            name: string;
-            load: (args_0: {
-                collection: string;
-                generateDigest: (args_0: any) => unknown;
-                config?: any;
-                meta?: any;
-                logger?: any;
-                store?: any;
-                entryTypes?: any;
-                parseData?: any;
-                renderMarkdown?: any;
-                watcher?: any;
-                refreshContextData?: Record<string, unknown> | undefined;
-            }) => unknown;
-            schema?: any;
-            render?: ((args_0: any) => unknown) | undefined;
-        }>]>;
-    }, "strip", z.ZodTypeAny, {
-        type: "content_layer";
-        loader: ((...args: unknown[]) => unknown) | {
-            name: string;
-            load: (args_0: {
-                collection: string;
-                generateDigest: (args_0: any) => unknown;
-                config?: any;
-                meta?: any;
-                logger?: any;
-                store?: any;
-                entryTypes?: any;
-                parseData?: any;
-                renderMarkdown?: any;
-                watcher?: any;
-                refreshContextData?: Record<string, unknown> | undefined;
-            }) => unknown;
-            schema?: any;
-            render?: ((args_0: any) => unknown) | undefined;
-        };
-        schema?: any;
-    }, {
-        type: "content_layer";
-        loader: ((...args: unknown[]) => unknown) | {
-            name: string;
-            load: (args_0: {
-                collection: string;
-                generateDigest: (args_0: any) => unknown;
-                config?: any;
-                meta?: any;
-                logger?: any;
-                store?: any;
-                entryTypes?: any;
-                parseData?: any;
-                renderMarkdown?: any;
-                watcher?: any;
-                refreshContextData?: Record<string, unknown> | undefined;
-            }) => unknown;
-            schema?: any;
-            render?: ((args_0: any) => unknown) | undefined;
-        };
-        schema?: any;
-    }>, z.ZodObject<{
+            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.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-    }, "strip", z.ZodTypeAny, {
-        type: "live";
-        loader: (...args: unknown[]) => unknown;
-        schema?: any;
-    }, {
-        loader: (...args: unknown[]) => unknown;
-        type?: "live" | undefined;
-        schema?: any;
-    }>]>>;
-}, "strip", z.ZodTypeAny, {
-    collections: Record<string, {
-        type: "content_layer";
-        loader: ((...args: unknown[]) => unknown) | {
-            name: string;
-            load: (args_0: {
-                collection: string;
-                generateDigest: (args_0: any) => unknown;
-                config?: any;
-                meta?: any;
-                logger?: any;
-                store?: any;
-                entryTypes?: any;
-                parseData?: any;
-                renderMarkdown?: any;
-                watcher?: any;
-                refreshContextData?: Record<string, unknown> | undefined;
-            }) => unknown;
-            schema?: any;
-            render?: ((args_0: any) => unknown) | undefined;
-        };
-        schema?: any;
-    } | {
-        type: "live";
-        loader: (...args: unknown[]) => unknown;
-        schema?: any;
-    }>;
-}, {
-    collections: Record<string, {
-        type: "content_layer";
-        loader: ((...args: unknown[]) => unknown) | {
-            name: string;
-            load: (args_0: {
-                collection: string;
-                generateDigest: (args_0: any) => unknown;
-                config?: any;
-                meta?: any;
-                logger?: any;
-                store?: any;
-                entryTypes?: any;
-                parseData?: any;
-                renderMarkdown?: any;
-                watcher?: any;
-                refreshContextData?: Record<string, unknown> | undefined;
-            }) => unknown;
-            schema?: any;
-            render?: ((args_0: any) => unknown) | undefined;
-        };
-        schema?: any;
-    } | {
-        loader: (...args: unknown[]) => unknown;
-        type?: "live" | undefined;
-        schema?: any;
-    }>;
-}>;
+        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> & {
     digest?: string;
@@ -358,21 +75,12 @@ export declare function parseEntrySlug({ id, collection, generatedSlug, frontmat
     generatedSlug: string;
     frontmatterSlug?: unknown;
 }): string;
-export declare function getEntryDataAndImages<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData extends TInputData = TInputData>(entry: {
+export declare function getEntryData<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData extends TInputData = TInputData>(entry: {
     id: string;
     collection: string;
     unvalidatedData: TInputData;
     _internal: EntryInternal;
-}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext?: PluginContext): Promise<{
-    data: TOutputData;
-    imageImports: Array<string>;
-}>;
-export declare function getEntryData(entry: {
-    id: string;
-    collection: string;
-    unvalidatedData: Record<string, unknown>;
-    _internal: EntryInternal;
-}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext?: PluginContext): Promise<Record<string, unknown>>;
+}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext?: PluginContext): Promise<TOutputData>;
 export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];
 export declare function getDataEntryExts(settings: Pick<AstroSettings, 'dataEntryTypes'>): string[];
 export declare function getEntryConfigByExtMap<TEntryType extends ContentEntryType | DataEntryType>(entryTypes: TEntryType[]): Map<string, TEntryType>;
@@ -413,7 +121,7 @@ export declare function isDeferredModule(viteId: string): boolean;
 export declare function reloadContentConfigObserver({ observer, ...loadContentConfigOpts }: {
     fs: typeof fsMod;
     settings: AstroSettings;
-    viteServer: ViteDevServer;
+    environment: RunnableDevEnvironment;
     observer?: ContentObservable;
 }): Promise<void>;
 type ContentCtx = {