astro 6.0.0-alpha.0 → 6.0.0-alpha.1

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

@@ -1,5 +1,5 @@
 import type { FSWatcher } from 'vite';
-import type { ZodSchema } from 'zod';
+import type * as z from 'zod/v4/core';
 import type { AstroIntegrationLogger } from '../../core/logger/core.js';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { LiveDataCollection, LiveDataEntry } from '../../types/public/content.js';
@@ -35,14 +35,21 @@ export interface LoaderContext {
     /** If the loader has been triggered by an integration, this may optionally contain extra data set by that integration */
     refreshContextData?: Record<string, unknown>;
 }
-export interface Loader {
+export type Loader = {
     /** Unique name of the loader, e.g. the npm package name */
     name: string;
     /** Do the actual loading of the data */
     load: (context: LoaderContext) => Promise<void>;
+} & ({
     /** Optionally, define the schema of the data. Will be overridden by user-defined schema */
-    schema?: ZodSchema | Promise<ZodSchema> | (() => ZodSchema | Promise<ZodSchema>);
-}
+    schema?: z.$ZodType;
+} | {
+    /** Optionally, provide a function to dynamically provide a schema. Will be overridden by user-defined schema */
+    createSchema?: () => Promise<{
+        schema: z.$ZodType;
+        types: string;
+    }>;
+});
 export interface LoadEntryContext<TEntryFilter = never> {
     filter: TEntryFilter extends never ? {
         id: string;

package/dist/content/runtime-assets.d.ts

@@ -1,11 +1,11 @@
 import type { PluginContext } from 'rollup';
-import { z } from 'zod';
-export declare function createImage(pluginContext: PluginContext, shouldEmitFile: boolean, entryFilePath: string): () => z.ZodEffects<z.ZodString, z.ZodNever | {
+import * as z from 'zod/v4';
+export declare function createImage(pluginContext: PluginContext, shouldEmitFile: boolean, entryFilePath: string): () => z.ZodPipe<z.ZodString, z.ZodTransform<z.ZodNever | {
     ASTRO_ASSET: string;
-    src: string;
     format: import("../assets/types.js").ImageInputFormat;
+    src: string;
     width: number;
     height: number;
     fsPath: string;
     orientation?: number | undefined;
-}, string>;
+}, string>>;

package/dist/content/runtime-assets.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { emitImageMetadata } from "../assets/utils/node/emitAsset.js";
+import * as z from "zod/v4";
+import { emitImageMetadata } from "../assets/utils/node.js";
 function createImage(pluginContext, shouldEmitFile, entryFilePath) {
   return () => {
     return z.string().transform(async (imagePath, ctx) => {

package/dist/content/runtime.d.ts

@@ -1,5 +1,6 @@
 import type { MarkdownHeading } from '@astrojs/markdown-remark';
-import { z } from 'zod';
+import * as z from 'zod/v4';
+import type * as zCore from 'zod/v4/core';
 import { type AstroComponentFactory } from '../runtime/server/index.js';
 import type { LiveDataCollectionResult, LiveDataEntryResult } from '../types/public/content.js';
 import { type LIVE_CONTENT_TYPE } from './consts.js';
@@ -10,7 +11,7 @@ export { LiveCollectionError, LiveCollectionCacheHintError, LiveEntryNotFoundErr
 type LiveCollectionConfigMap = Record<string, {
     loader: LiveLoader;
     type: typeof LIVE_CONTENT_TYPE;
-    schema?: z.ZodType;
+    schema?: zCore.$ZodType;
 }>;
 export declare function createGetCollection({ liveCollections, }: {
     liveCollections: LiveCollectionConfigMap;
@@ -67,25 +68,13 @@ type RenderResult = {
     remarkPluginFrontmatter: Record<string, any>;
 };
 export declare function renderEntry(entry: DataEntry): Promise<RenderResult>;
-export declare function createReference(): (collection: string) => z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodObject<{
+export declare function createReference(): (collection: string) => z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     id: z.ZodString;
     collection: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    collection: string;
-}, {
-    id: string;
-    collection: string;
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     slug: z.ZodString;
     collection: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    collection: string;
-    slug: string;
-}, {
-    collection: string;
-    slug: string;
-}>]>, {
+}, z.core.$strip>]>, z.ZodTransform<{
     id: string;
     collection: string;
 } | {
@@ -95,9 +84,21 @@ export declare function createReference(): (collection: string) => z.ZodEffects<
     id: string;
     collection: string;
 } | {
-    collection: string;
     slug: string;
-}>;
-export declare function defineCollection(config: any): import("./config.js").CollectionConfig<import("./config.js").BaseSchema>;
+    collection: string;
+}>>;
+export declare function defineCollection(config: any): import("./config.js").CollectionConfig<import("./config.js").BaseSchema, import("./loaders/types.js").Loader | (() => {
+    id: string;
+}[] | Promise<{
+    id: string;
+}[]> | Record<string, Omit<{
+    id: string;
+}, "id"> & {
+    id?: string;
+}> | Promise<Record<string, Omit<{
+    id: string;
+}, "id"> & {
+    id?: string;
+}>>)>;
 export declare function defineLiveCollection(): void;
 export declare function createDeprecatedFunction(functionName: string): (collection: string) => never;

package/dist/content/runtime.js

@@ -1,6 +1,6 @@
 import { escape } from "html-escaper";
 import { Traverse } from "neotraverse/modern";
-import { ZodIssueCode, z } from "zod";
+import * as z from "zod/v4";
 import { imageSrcToImportId } from "../assets/utils/resolveImports.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { prependForwardSlash } from "../core/path.js";
@@ -29,7 +29,7 @@ const cacheHintSchema = z.object({
 });
 async function parseLiveEntry(entry, schema, collection) {
   try {
-    const parsed = await schema.safeParseAsync(entry.data);
+    const parsed = await z.safeParseAsync(schema, entry.data);
     if (!parsed.success) {
       return {
         error: new LiveCollectionValidationError(collection, entry.id, parsed.error)
@@ -480,22 +480,20 @@ function createReference() {
         slug: z.string(),
         collection: z.string()
       })
-    ]).transform(
-      (lookup, ctx) => {
-        const flattenedErrorPath = ctx.path.join(".");
-        if (typeof lookup === "object") {
-          if (lookup.collection !== collection) {
-            ctx.addIssue({
-              code: ZodIssueCode.custom,
-              message: `**${flattenedErrorPath}**: Reference to ${collection} invalid. Expected ${collection}. Received ${lookup.collection}.`
-            });
-            return;
-          }
-          return lookup;
+    ]).transform((lookup, ctx) => {
+      if (typeof lookup === "object") {
+        if (lookup.collection !== collection) {
+          const flattenedErrorPath = ctx.issues[0]?.path?.join(".");
+          ctx.addIssue({
+            code: "custom",
+            message: `**${flattenedErrorPath}**: Reference to ${collection} invalid. Expected ${collection}. Received ${lookup.collection}.`
+          });
+          return;
         }
-        return { id: lookup, collection };
+        return lookup;
       }
-    );
+      return { id: lookup, collection };
+    });
   };
 }
 function isPropagatedAssetsModule(module) {

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,13 @@ 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);
+    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",