astro 4.10.2 → 4.11.0

package/components/Code.astro

@@ -3,6 +3,7 @@ import type { ThemePresets } from '@astrojs/markdown-remark';
 import type {
 	BuiltinLanguage,
 	LanguageRegistration,
+	ShikiTransformer,
 	SpecialLanguage,
 	ThemeRegistration,
 	ThemeRegistrationRaw,
@@ -50,6 +51,12 @@ interface Props extends Omit<HTMLAttributes<'pre'>, 'lang'> {
 	 * @default false
 	 */
 	inline?: boolean;
+	/**
+	 * Shiki transformers to customize the generated HTML by manipulating the hast tree.
+	 * Supports all transformers listed here: https://shiki.style/packages/transformers#transformers
+	 * Instructions for custom transformers: https://shiki.style/guide/transformers
+	 */
+	transformers?: ShikiTransformer[];
 }
 
 const {
@@ -59,6 +66,7 @@ const {
 	themes = {},
 	wrap = false,
 	inline = false,
+	transformers = [],
 	...rest
 } = Astro.props;
 
@@ -85,6 +93,7 @@ const highlighter = await getCachedHighlighter({
 	theme,
 	themes,
 	wrap,
+	transformers,
 });
 
 const html = await highlighter.highlight(code, typeof lang === 'string' ? lang : lang.name, {

package/dist/@types/astro.d.ts

@@ -211,7 +211,7 @@ export interface AstroGlobal<Props extends Record<string, any> = Record<string,
     /**
      * The <Astro.self /> element allows a component to reference itself recursively.
      *
-     * [Astro reference](https://docs.astro.build/en/guides/api-reference/#astroself)
+     * [Astro reference](https://docs.astro.build/en/reference/api-reference/#astroself)
      */
     self: Self;
     /** Utility functions for modifying an Astro component’s slotted children
@@ -1295,7 +1295,7 @@ export interface AstroUserConfig {
          * import remarkToc from 'remark-toc';
          * {
          *   markdown: {
-         *     remarkPlugins: [remarkToc]
+         *     remarkPlugins: [ [remarkToc, { heading: "contents"} ] ]
          *   }
          * }
          * ```
@@ -1931,17 +1931,17 @@ export interface AstroUserConfig {
          *
          * ```astro
          * ---
-         * import { PUBLIC_APP_ID } from "astro:env/client"
-         * import { PUBLIC_API_URL, getSecret } from "astro:env/server"
-         * const API_TOKEN = getSecret("API_TOKEN")
+         * import { APP_ID } from "astro:env/client"
+         * import { API_URL, API_TOKEN, getSecret } from "astro:env/server"
+         * const NODE_ENV = getSecret("NODE_ENV")
          *
-         * const data = await fetch(`${PUBLIC_API_URL}/users`, {
+         * const data = await fetch(`${API_URL}/users`, {
          * 	method: "POST",
          * 	headers: {
          * 		"Content-Type": "application/json",
          * 		"Authorization": `Bearer ${API_TOKEN}`
          * 	},
-         * 	body: JSON.stringify({ appId: PUBLIC_APP_ID })
+         * 	body: JSON.stringify({ appId: APP_ID, nodeEnv: NODE_ENV })
          * })
          * ---
          * ```
@@ -1956,8 +1956,8 @@ export interface AstroUserConfig {
          *     experimental: {
          *         env: {
          *             schema: {
-         *                 PUBLIC_API_URL: envField.string({ context: "client", access: "public", optional: true }),
-         *                 PUBLIC_PORT: envField.number({ context: "server", access: "public", default: 4321 }),
+         *                 API_URL: envField.string({ context: "client", access: "public", optional: true }),
+         *                 PORT: envField.number({ context: "server", access: "public", default: 4321 }),
          *                 API_SECRET: envField.string({ context: "server", access: "secret" }),
          *             }
          *         }
@@ -1965,28 +1965,27 @@ export interface AstroUserConfig {
          * })
          * ```
          *
-         * There are currently three data types supported: strings, numbers and booleans.
+         * There are currently four data types supported: strings, numbers, booleans and enums.
          *
          * There are three kinds of environment variables, determined by the combination of `context` (client or server) and `access` (secret or public) settings defined in your [`env.schema`](#experimentalenvschema):
          *
          * - **Public client variables**: These variables end up in both your final client and server bundles, and can be accessed from both client and server through the `astro:env/client` module:
          *
          *     ```js
-         *     import { PUBLIC_API_URL } from "astro:env/client"
+         *     import { API_URL } from "astro:env/client"
          *     ```
          *
          * - **Public server variables**: These variables end up in your final server bundle and can be accessed on the server through the `astro:env/server` module:
          *
          *     ```js
-         *     import { PUBLIC_PORT } from "astro:env/server"
+         *     import { PORT } from "astro:env/server"
          *     ```
          *
-         * - **Secret server variables**: These variables are not part of your final bundle and can be accessed on the server through the `getSecret()` helper function available from the `astro:env/server` module:
+         * - **Secret server variables**: These variables are not part of your final bundle and can be accessed on the server through the `astro:env/server` module. The `getSecret()` helper function can be used to retrieve secrets not specified in the schema:
          *
          *     ```js
-         *     import { getSecret } from "astro:env/server"
+         *     import { API_SECRET, getSecret } from "astro:env/server"
          *
-         *     const API_SECRET = getSecret("API_SECRET") // typed
          *     const SECRET_NOT_IN_SCHEMA = getSecret("SECRET_NOT_IN_SCHEMA") // string | undefined
          *     ```
          *
@@ -2013,8 +2012,8 @@ export interface AstroUserConfig {
              *   experimental: {
              *     env: {
              *       schema: {
-             *         PUBLIC_API_URL: envField.string({ context: "client", access: "public", optional: true }),
-             *         PUBLIC_PORT: envField.number({ context: "server", access: "public", default: 4321 }),
+             *         API_URL: envField.string({ context: "client", access: "public", optional: true }),
+             *         PORT: envField.number({ context: "server", access: "public", default: 4321 }),
              *         API_SECRET: envField.string({ context: "server", access: "secret" }),
              *       }
              *     }
@@ -2604,7 +2603,7 @@ export interface APIContext<Props extends Record<string, any> = Record<string, a
      * }
      * ```
      *
-     * [Reference](https://docs.astro.build/en/guides/api-reference/#contextprops)
+     * [Reference](https://docs.astro.build/en/reference/api-reference/#contextprops)
      */
     props: AstroSharedContext<Props, APIParams>['props'];
     /**
@@ -2711,27 +2710,32 @@ export interface AstroRenderer {
     /** @deprecated Vite plugins should transform the JSX instead */
     jsxTransformOptions?: JSXTransformFn;
 }
-export interface SSRLoadedRenderer extends AstroRenderer {
-    ssr: {
-        check: AsyncRendererComponentFn<boolean>;
-        renderToStaticMarkup: AsyncRendererComponentFn<{
-            html: string;
-            attrs?: Record<string, string>;
-        }>;
-        supportsAstroStaticSlot?: boolean;
-        /**
-         * If provided, Astro will call this function and inject the returned
-         * script in the HTML before the first component handled by this renderer.
-         *
-         * This feature is needed by some renderers (in particular, by Solid). The
-         * Solid official hydration script sets up a page-level data structure.
-         * It is mainly used to transfer data between the server side render phase
-         * and the browser application state. Solid Components rendered later in
-         * the HTML may inject tiny scripts into the HTML that call into this
-         * page-level data structure.
-         */
-        renderHydrationScript?: () => string;
-    };
+export interface NamedSSRLoadedRendererValue extends SSRLoadedRendererValue {
+    name: string;
+}
+export interface SSRLoadedRendererValue {
+    name?: string;
+    check: AsyncRendererComponentFn<boolean>;
+    renderToStaticMarkup: AsyncRendererComponentFn<{
+        html: string;
+        attrs?: Record<string, string>;
+    }>;
+    supportsAstroStaticSlot?: boolean;
+    /**
+     * If provided, Astro will call this function and inject the returned
+     * script in the HTML before the first component handled by this renderer.
+     *
+     * This feature is needed by some renderers (in particular, by Solid). The
+     * Solid official hydration script sets up a page-level data structure.
+     * It is mainly used to transfer data between the server side render phase
+     * and the browser application state. Solid Components rendered later in
+     * the HTML may inject tiny scripts into the HTML that call into this
+     * page-level data structure.
+     */
+    renderHydrationScript?: () => string;
+}
+export interface SSRLoadedRenderer extends Pick<AstroRenderer, 'name' | 'clientEntrypoint'> {
+    ssr: SSRLoadedRendererValue;
 }
 export type HookParameters<Hook extends keyof AstroIntegration['hooks'], Fn = AstroIntegration['hooks'][Hook]> = Fn extends (...args: any) => any ? Parameters<Fn>[0] : never;
 export interface AstroIntegration {

package/dist/actions/runtime/virtual/server.d.ts

@@ -14,7 +14,7 @@ export type ActionClient<TOutput, TAccept extends Accept, TInputSchema extends I
 } : ((input?: any) => Promise<Awaited<TOutput>>) & {
     safe: (input?: any) => Promise<SafeResult<never, Awaited<TOutput>>>;
 };
-export declare function defineAction<TOutput, TAccept extends Accept = 'json', TInputSchema extends InputSchema<Accept> | undefined = TAccept extends 'form' ? z.ZodType<FormData> : undefined>({ accept, input: inputSchema, handler, }: {
+export declare function defineAction<TOutput, TAccept extends Accept, TInputSchema extends InputSchema<Accept> | undefined = TAccept extends 'form' ? z.ZodType<FormData> : undefined>({ accept, input: inputSchema, handler, }: {
     input?: TInputSchema;
     accept?: TAccept;
     handler: Handler<TInputSchema, TOutput>;

package/dist/assets/internal.d.ts

@@ -1,5 +1,5 @@
 import type { AstroConfig } from '../@types/astro.js';
 import { type ImageService } from './services/service.js';
-import type { GetImageResult, UnresolvedImageTransform } from './types.js';
+import { type GetImageResult, type UnresolvedImageTransform } from './types.js';
 export declare function getConfiguredImageService(): Promise<ImageService>;
 export declare function getImage(options: UnresolvedImageTransform, imageConfig: AstroConfig['image']): Promise<GetImageResult>;

package/dist/assets/internal.js

@@ -1,6 +1,9 @@
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { DEFAULT_HASH_PROPS } from "./consts.js";
 import { isLocalService } from "./services/service.js";
+import {
+  isImageMetadata
+} from "./types.js";
 import { isESMImportedImage, isRemoteImage, resolveSrc } from "./utils/imageKind.js";
 import { probe } from "./utils/remoteProbe.js";
 async function getConfiguredImageService() {
@@ -36,6 +39,9 @@ async function getImage(options, imageConfig) {
       )
     });
   }
+  if (isImageMetadata(options)) {
+    throw new AstroError(AstroErrorData.ExpectedNotESMImage);
+  }
   const service = await getConfiguredImageService();
   const resolvedOptions = {
     ...options,

package/dist/assets/types.d.ts

@@ -20,16 +20,20 @@ declare global {
         referencedImages?: Set<string>;
     };
 }
+declare const isESMImport: unique symbol;
+export type OmitBrand<T> = Omit<T, typeof isESMImport>;
 /**
  * Type returned by ESM imports of images
  */
-export interface ImageMetadata {
+export type ImageMetadata = {
     src: string;
     width: number;
     height: number;
     format: ImageInputFormat;
     orientation?: number;
-}
+    [isESMImport]?: true;
+};
+export declare function isImageMetadata(src: any): src is ImageMetadata;
 /**
  * A yet to be completed with an url `SrcSetValue`. Other hooks will only see a resolved value, where the URL of the image has been added.
  */
@@ -49,6 +53,8 @@ export type UnresolvedImageTransform = Omit<ImageTransform, 'src'> & {
         default: ImageMetadata;
     }>;
     inferSize?: boolean;
+} & {
+    [isESMImport]?: never;
 };
 /**
  * Options accepted by the image transformation service.

package/dist/assets/types.js

@@ -0,0 +1,7 @@
+const isESMImport = Symbol("#isESM");
+function isImageMetadata(src) {
+  return src.fsPath && !("fsPath" in src);
+}
+export {
+  isImageMetadata
+};

package/dist/container/index.d.ts

@@ -1,4 +1,4 @@
-import type { AstroUserConfig, Props, RouteType, SSRLoadedRenderer, SSRManifest, SSRResult } from '../@types/astro.js';
+import type { AstroUserConfig, NamedSSRLoadedRendererValue, Props, RouteType, SSRLoadedRenderer, SSRLoadedRendererValue, SSRManifest, SSRResult } from '../@types/astro.js';
 import type { AstroComponentFactory } from '../runtime/server/index.js';
 /**
  * Options to be passed when rendering a route
@@ -59,6 +59,13 @@ export type ContainerRenderOptions = {
      */
     props?: Props;
 };
+export type AddServerRenderer = {
+    renderer: NamedSSRLoadedRendererValue;
+    name: never;
+} | {
+    renderer: SSRLoadedRendererValue;
+    name: string;
+};
 export type AstroContainerUserConfig = Omit<AstroUserConfig, 'integrations' | 'adapter'>;
 /**
  * Options that are used for the entire lifecycle of the current instance of the container.
@@ -122,6 +129,30 @@ export declare class experimental_AstroContainer {
      * @param {AstroContainerOptions=} containerOptions
      */
     static create(containerOptions?: AstroContainerOptions): Promise<experimental_AstroContainer>;
+    /**
+     * Use this function to manually add a renderer to the container.
+     *
+     * This function is preferred when you require to use the container with a renderer in environments such as on-demand pages.
+     *
+     * ## Example
+     *
+     * ```js
+     * import reactRenderer from "@astrojs/react/server.js";
+     * import vueRenderer from "@astrojs/vue/server.js";
+     * import customRenderer from "../renderer/customRenderer.js";
+     * import { experimental_AstroContainer as AstroContainer } from "astro/container"
+     *
+     * const container = await AstroContainer.create();
+     * container.addServerRenderer(reactRenderer);
+     * container.addServerRenderer(vueRenderer);
+     * container.addServerRenderer("customRenderer", customRenderer);
+     * ```
+     *
+     * @param options {object}
+     * @param options.name The name of the renderer. The name **isn't** arbitrary, and it should match the name of the package.
+     * @param options.renderer The server renderer exported by integration.
+     */
+    addServerRenderer(options: AddServerRenderer): void;
     private static createFromManifest;
     /**
      * @description

package/dist/container/index.js

@@ -93,6 +93,48 @@ class experimental_AstroContainer {
       resolve
     });
   }
+  /**
+   * Use this function to manually add a renderer to the container.
+   *
+   * This function is preferred when you require to use the container with a renderer in environments such as on-demand pages.
+   *
+   * ## Example
+   *
+   * ```js
+   * import reactRenderer from "@astrojs/react/server.js";
+   * import vueRenderer from "@astrojs/vue/server.js";
+   * import customRenderer from "../renderer/customRenderer.js";
+   * import { experimental_AstroContainer as AstroContainer } from "astro/container"
+   *
+   * const container = await AstroContainer.create();
+   * container.addServerRenderer(reactRenderer);
+   * container.addServerRenderer(vueRenderer);
+   * container.addServerRenderer("customRenderer", customRenderer);
+   * ```
+   *
+   * @param options {object}
+   * @param options.name The name of the renderer. The name **isn't** arbitrary, and it should match the name of the package.
+   * @param options.renderer The server renderer exported by integration.
+   */
+  addServerRenderer(options) {
+    const { renderer, name } = options;
+    if (!renderer.check || !renderer.renderToStaticMarkup) {
+      throw new Error(
+        "The renderer you passed isn't valid. A renderer is usually an object that exposes the `check` and `renderToStaticMarkup` functions.\nUsually, the renderer is exported by a /server.js entrypoint e.g. `import renderer from '@astrojs/react/server.js'`"
+      );
+    }
+    if (isNamedRenderer(renderer)) {
+      this.#pipeline.manifest.renderers.push({
+        name: renderer.name,
+        ssr: renderer
+      });
+    } else {
+      this.#pipeline.manifest.renderers.push({
+        name,
+        ssr: renderer
+      });
+    }
+  }
   // NOTE: we keep this private via TS instead via `#` so it's still available on the surface, so we can play with it.
   // @ematipico: I plan to use it for a possible integration that could help people
   static async createFromManifest(manifest) {
@@ -234,6 +276,9 @@ class experimental_AstroContainer {
     return { default: componentFactory };
   }
 }
+function isNamedRenderer(renderer) {
+  return !!renderer?.name;
+}
 export {
   experimental_AstroContainer
 };

package/dist/container/pipeline.d.ts

@@ -8,5 +8,4 @@ export declare class ContainerPipeline extends Pipeline {
     tryRewrite(payload: RewritePayload, request: Request): Promise<[RouteData, ComponentInstance, URL]>;
     insertRoute(route: RouteData, componentInstance: ComponentInstance): void;
     getComponentByRoute(_routeData: RouteData): Promise<ComponentInstance>;
-    rewriteKnownRoute(pathname: string, _sourceRoute: RouteData): ComponentInstance;
 }

package/dist/container/pipeline.js

@@ -1,11 +1,12 @@
 import { Pipeline } from "../core/base-pipeline.js";
-import { InvalidRewrite404, RouteNotFound } from "../core/errors/errors-data.js";
+import { RouteNotFound } from "../core/errors/errors-data.js";
 import { AstroError } from "../core/errors/index.js";
 import {
   createModuleScriptElement,
   createStylesheetElementSet
 } from "../core/render/ssr-element.js";
-import { DEFAULT_404_ROUTE, default404Page } from "../core/routing/astro-designed-error-pages.js";
+import { DEFAULT_404_ROUTE } from "../core/routing/astro-designed-error-pages.js";
+import { findRouteToRewrite } from "../core/routing/rewrite.js";
 class ContainerPipeline extends Pipeline {
   /**
    * Internal cache to store components instances by `RouteData`.
@@ -52,30 +53,16 @@ class ContainerPipeline extends Pipeline {
     return { links, styles, scripts };
   }
   async tryRewrite(payload, request) {
-    let foundRoute;
-    let finalUrl = void 0;
-    for (const route of this.manifest.routes) {
-      if (payload instanceof URL) {
-        finalUrl = payload;
-      } else if (payload instanceof Request) {
-        finalUrl = new URL(payload.url);
-      } else {
-        finalUrl = new URL(payload, new URL(request.url).origin);
-      }
-      if (route.routeData.pattern.test(decodeURI(finalUrl.pathname))) {
-        foundRoute = route.routeData;
-        break;
-      } else if (finalUrl.pathname === "/404") {
-        foundRoute = DEFAULT_404_ROUTE;
-        break;
-      }
-    }
-    if (foundRoute && finalUrl) {
-      const componentInstance = await this.getComponentByRoute(foundRoute);
-      return [foundRoute, componentInstance, finalUrl];
-    } else {
-      throw new AstroError(RouteNotFound);
-    }
+    const [foundRoute, finalUrl] = findRouteToRewrite({
+      payload,
+      request,
+      routes: this.manifest?.routes.map((r) => r.routeData),
+      trailingSlash: this.manifest.trailingSlash,
+      buildFormat: this.manifest.buildFormat,
+      base: this.manifest.base
+    });
+    const componentInstance = await this.getComponentByRoute(foundRoute);
+    return [foundRoute, componentInstance, finalUrl];
   }
   insertRoute(route, componentInstance) {
     this.#componentsInterner.set(route, {
@@ -90,12 +77,6 @@ class ContainerPipeline extends Pipeline {
   // @ts-expect-error It needs to be implemented.
   async getComponentByRoute(_routeData) {
   }
-  rewriteKnownRoute(pathname, _sourceRoute) {
-    if (pathname === "/404") {
-      return { default: default404Page };
-    }
-    throw new AstroError(InvalidRewrite404);
-  }
 }
 export {
   ContainerPipeline

package/dist/container/vite-plugin-container.d.ts

@@ -0,0 +1,2 @@
+import type * as vite from 'vite';
+export default function astroContainer(): vite.Plugin;

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

@@ -0,0 +1,15 @@
+const virtualModuleId = "astro:container";
+function astroContainer() {
+  return {
+    name: "astro:container",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === virtualModuleId) {
+        return this.resolve("astro/virtual-modules/container.js");
+      }
+    }
+  };
+}
+export {
+  astroContainer as default
+};

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

@@ -2,10 +2,10 @@ 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 | {
     ASTRO_ASSET: string;
-    src: string;
+    format: "jpeg" | "jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "avif";
     width: number;
     height: number;
-    format: "jpeg" | "jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "avif";
-    orientation?: number | undefined;
+    src: string;
     fsPath: string;
+    orientation?: number | undefined;
 }, string>;

package/dist/content/types-generator.js

@@ -318,13 +318,26 @@ async function writeContentFiles({
       // This ensures `getCollection('empty-collection')` doesn't raise a type error
       collectionConfig?.type ?? "data"
     ) : collection.type;
+    const collectionEntryKeys = Object.keys(collection.entries).sort();
+    const dataType = collectionConfig?.schema ? `InferEntrySchema<${collectionKey}>` : "any";
     switch (resolvedType) {
       case "content":
+        if (collectionEntryKeys.length === 0) {
+          contentTypesStr += `${collectionKey}: Record<string, {
+  id: string;
+  slug: string;
+  body: string;
+  collection: ${collectionKey};
+  data: ${dataType};
+  render(): Render[".md"];
+}>;
+`;
+          break;
+        }
         contentTypesStr += `${collectionKey}: {
 `;
-        for (const entryKey of Object.keys(collection.entries).sort()) {
+        for (const entryKey of collectionEntryKeys) {
           const entryMetadata = collection.entries[entryKey];
-          const dataType = collectionConfig?.schema ? `InferEntrySchema<${collectionKey}>` : "any";
           const renderType = `{ render(): Render[${JSON.stringify(
             path.extname(JSON.parse(entryKey))
           )}] }`;
@@ -342,46 +355,54 @@ async function writeContentFiles({
 `;
         break;
       case "data":
-        dataTypesStr += `${collectionKey}: {
+        if (collectionEntryKeys.length === 0) {
+          dataTypesStr += `${collectionKey}: Record<string, {
+  id: string;
+  collection: ${collectionKey};
+  data: ${dataType};
+}>;
 `;
-        for (const entryKey of Object.keys(collection.entries).sort()) {
-          const dataType = collectionConfig?.schema ? `InferEntrySchema<${collectionKey}>` : "any";
-          dataTypesStr += `${entryKey}: {
+        } else {
+          dataTypesStr += `${collectionKey}: {
+`;
+          for (const entryKey of collectionEntryKeys) {
+            dataTypesStr += `${entryKey}: {
 	id: ${entryKey};
   collection: ${collectionKey};
   data: ${dataType}
 };
 `;
-          if (settings.config.experimental.contentCollectionJsonSchema && collectionConfig?.schema) {
-            let zodSchemaForJson = typeof collectionConfig.schema === "function" ? collectionConfig.schema({ image: () => z.string() }) : collectionConfig.schema;
-            if (zodSchemaForJson instanceof z.ZodObject) {
-              zodSchemaForJson = zodSchemaForJson.extend({
-                $schema: z.string().optional()
-              });
-            }
-            try {
-              await fs.promises.writeFile(
-                new URL(`./${collectionKey.replace(/"/g, "")}.schema.json`, collectionSchemasDir),
-                JSON.stringify(
-                  zodToJsonSchema(zodSchemaForJson, {
-                    name: collectionKey.replace(/"/g, ""),
-                    markdownDescription: true,
-                    errorMessages: true
-                  }),
-                  null,
-                  2
-                )
-              );
-            } catch (err) {
-              logger.warn(
-                "content",
-                `An error was encountered while creating the JSON schema for the ${entryKey} entry in ${collectionKey} collection. Proceeding without it. Error: ${err}`
-              );
-            }
           }
-        }
-        dataTypesStr += `};
+          dataTypesStr += `};
 `;
+        }
+        if (settings.config.experimental.contentCollectionJsonSchema && collectionConfig?.schema) {
+          let zodSchemaForJson = typeof collectionConfig.schema === "function" ? collectionConfig.schema({ image: () => z.string() }) : collectionConfig.schema;
+          if (zodSchemaForJson instanceof z.ZodObject) {
+            zodSchemaForJson = zodSchemaForJson.extend({
+              $schema: z.string().optional()
+            });
+          }
+          try {
+            await fs.promises.writeFile(
+              new URL(`./${collectionKey.replace(/"/g, "")}.schema.json`, collectionSchemasDir),
+              JSON.stringify(
+                zodToJsonSchema(zodSchemaForJson, {
+                  name: collectionKey.replace(/"/g, ""),
+                  markdownDescription: true,
+                  errorMessages: true
+                }),
+                null,
+                2
+              )
+            );
+          } catch (err) {
+            logger.warn(
+              "content",
+              `An error was encountered while creating the JSON schema for the ${collectionKey} collection. Proceeding without it. Error: ${err}`
+            );
+          }
+        }
         break;
     }
   }

package/dist/content/utils.d.ts

@@ -5,6 +5,7 @@ import type { PluginContext } from 'rollup';
 import { type ViteDevServer } from 'vite';
 import { z } from 'zod';
 import type { AstroConfig, AstroSettings, ContentEntryType, DataEntryType } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
 import { CONTENT_FLAGS } from './consts.js';
 /**
  * Amap from a collection + slug to the local file path.
@@ -99,6 +100,16 @@ export declare function getEntryData(entry: {
 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>;
+export declare function getSymlinkedContentCollections({ contentDir, logger, fs, }: {
+    contentDir: URL;
+    logger: Logger;
+    fs: typeof fsMod;
+}): Promise<Map<string, string>>;
+export declare function reverseSymlink({ entry, symlinks, contentDir, }: {
+    entry: string | URL;
+    contentDir: string | URL;
+    symlinks?: Map<string, string>;
+}): string;
 export declare function getEntryCollectionName({ contentDir, entry, }: Pick<ContentPaths, 'contentDir'> & {
     entry: string | URL;
 }): string | undefined;