astro 4.12.2 → 4.13.0

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

@@ -182,7 +182,7 @@ export interface AstroGlobal<Props extends Record<string, any> = Record<string,
      * ```
      */
     getActionResult: AstroSharedContext['getActionResult'];
-    /** Redirect to another page (**SSR Only**)
+    /** Redirect to another page
      *
      * Example usage:
      * ```typescript
@@ -191,7 +191,7 @@ export interface AstroGlobal<Props extends Record<string, any> = Record<string,
      * }
      * ```
      *
-     * [Astro reference](https://docs.astro.build/en/guides/server-side-rendering/)
+     * [Astro reference](https://docs.astro.build/en/reference/api-reference/#astroredirect)
      */
     redirect: AstroSharedContext['redirect'];
     /**
@@ -1755,53 +1755,6 @@ export interface AstroUserConfig {
          * ```
          */
         contentCollectionCache?: boolean;
-        /**
-         * @docs
-         * @name experimental.contentCollectionJsonSchema
-         * @type {boolean}
-         * @default `false`
-         * @version 4.5.0
-         * @description
-         * This feature will auto-generate a JSON schema for content collections of `type: 'data'` which can be used as the `$schema` value for TypeScript-style autocompletion/hints in tools like VSCode.
-         *
-         * To enable this feature, add the experimental flag:
-         *
-         * ```diff
-         * import { defineConfig } from 'astro/config';
-
-         * export default defineConfig({
-         * 	experimental: {
-         * +		contentCollectionJsonSchema: true
-         * 	}
-         * });
-         * ```
-         *
-         * This experimental implementation requires you to manually reference the schema in each data entry file of the collection:
-         *
-         * ```diff
-         * // src/content/test/entry.json
-         * {
-         * +  "$schema": "../../../.astro/collections/test.schema.json",
-         * 	"test": "test"
-         * }
-         * ```
-         *
-         * Alternatively, you can set this in your [VSCode `json.schemas` settings](https://code.visualstudio.com/docs/languages/json#_json-schemas-and-settings):
-         *
-         * ```diff
-         * "json.schemas": [
-         * 	{
-         * 		"fileMatch": [
-         * 			"/src/content/test/**"
-         * 		],
-         * 		"url": "./.astro/collections/test.schema.json"
-         * 	}
-         * ]
-         * ```
-         *
-         * Note that this initial implementation uses a library with [known issues for advanced Zod schemas](https://github.com/StefanTerdell/zod-to-json-schema#known-issues), so you may wish to consult these limitations before enabling the experimental flag.
-         */
-        contentCollectionJsonSchema?: boolean;
         /**
          * @docs
          * @name experimental.clientPrerender
@@ -1866,61 +1819,6 @@ export interface AstroUserConfig {
          * In the event of route collisions, where two routes of equal route priority attempt to build the same URL, Astro will log a warning identifying the conflicting routes.
          */
         globalRoutePriority?: boolean;
-        /**
-         * @docs
-         * @name experimental.rewriting
-         * @type {boolean}
-         * @default `false`
-         * @version 4.8.0
-         * @description
-         *
-         * Enables a routing feature for rewriting requests in Astro pages, endpoints and Astro middleware, giving you programmatic control over your routes.
-         *
-         * ```js
-         * {
-         *   experimental: {
-         *     rewriting: true,
-         *   },
-         * }
-         * ```
-         *
-         * Use `Astro.rewrite` in your `.astro` files to reroute to a different page:
-         *
-         * ```astro "rewrite"
-         * ---
-         * // src/pages/dashboard.astro
-         * if (!Astro.props.allowed) {
-         * 	return Astro.rewrite("/")
-         * }
-         * ---
-         * ```
-         *
-         * Use `context.rewrite` in your endpoint files to reroute to a different page:
-         *
-         * ```js
-         * // src/pages/api.js
-         * export function GET(ctx) {
-         * 	if (!ctx.locals.allowed) {
-         * 		return ctx.rewrite("/")
-         * 	}
-         * }
-         * ```
-         *
-         * Use `next("/")` in your middleware file to reroute to a different page, and then call the next middleware function:
-         *
-         * ```js
-         * // src/middleware.js
-         * export function onRequest(ctx, next) {
-         * 	if (!ctx.cookies.get("allowed")) {
-         * 		return next("/") // new signature
-         * 	}
-         * 	return next();
-         * }
-         * ```
-         *
-         * For a complete overview, and to give feedback on this experimental API, see the [Rerouting RFC](https://github.com/withastro/roadmap/blob/feat/reroute/proposals/0047-rerouting.md).
-         */
-        rewriting?: boolean;
         /**
          * @docs
          * @name experimental.env
@@ -2482,7 +2380,7 @@ export interface Page<T = any> {
     total: number;
     /** the current page number, starting from 1 */
     currentPage: number;
-    /** number of items per page (default: 25) */
+    /** number of items per page (default: 10) */
     size: number;
     /** number of last page */
     lastPage: number;
@@ -2593,7 +2491,7 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
     /**
      * Get action result on the server when using a form POST.
      */
-    getActionResult: <TAccept extends ActionAccept, TInputSchema extends ActionInputSchema<TAccept>, TAction extends ActionClient<unknown, TAccept, TInputSchema>>(action: TAction) => Awaited<ReturnType<TAction['safe']>> | undefined;
+    getActionResult: <TAccept extends ActionAccept, TInputSchema extends ActionInputSchema<TAccept>, TAction extends ActionClient<unknown, TAccept, TInputSchema>>(action: TAction) => Awaited<ReturnType<TAction>> | undefined;
     /**
      * Route parameters for this request if this is a dynamic route.
      */
@@ -3013,6 +2911,7 @@ export interface SSRResult {
      * Whether the page has failed with a non-recoverable error, or the client disconnected.
      */
     cancelled: boolean;
+    base: string;
     styles: Set<SSRElement>;
     scripts: Set<SSRElement>;
     links: Set<SSRElement>;
@@ -3037,6 +2936,7 @@ export interface SSRResult {
     pathname: string;
     cookies: AstroCookies | undefined;
     serverIslandNameMap: Map<string, string>;
+    trailingSlash: AstroConfig['trailingSlash'];
     _metadata: SSRMetadata;
 }
 /**

package/dist/actions/consts.d.ts

@@ -1,3 +1,6 @@
 export declare const VIRTUAL_MODULE_ID = "astro:actions";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
 export declare const ACTIONS_TYPES_FILE = "actions.d.ts";
+export declare const VIRTUAL_INTERNAL_MODULE_ID = "astro:internal-actions";
+export declare const RESOLVED_VIRTUAL_INTERNAL_MODULE_ID = "\0astro:internal-actions";
+export declare const NOOP_ACTIONS = "\0noop-actions";

package/dist/actions/consts.js

@@ -1,8 +1,14 @@
 const VIRTUAL_MODULE_ID = "astro:actions";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
 const ACTIONS_TYPES_FILE = "actions.d.ts";
+const VIRTUAL_INTERNAL_MODULE_ID = "astro:internal-actions";
+const RESOLVED_VIRTUAL_INTERNAL_MODULE_ID = "\0astro:internal-actions";
+const NOOP_ACTIONS = "\0noop-actions";
 export {
   ACTIONS_TYPES_FILE,
+  NOOP_ACTIONS,
+  RESOLVED_VIRTUAL_INTERNAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
+  VIRTUAL_INTERNAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 };

package/dist/actions/index.d.ts

@@ -1,5 +1,15 @@
 import fsMod from 'node:fs';
-import type { AstroIntegration } from '../@types/astro.js';
-export default function astroActions({ fs }: {
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroIntegration, AstroSettings } from '../@types/astro.js';
+export default function astroActions({ fs, settings, }: {
     fs?: typeof fsMod;
+    settings: AstroSettings;
 }): AstroIntegration;
+/**
+ * This plugin is responsible to load the known file `actions/index.js` / `actions.js`
+ * If the file doesn't exist, it returns an empty object.
+ * @param settings
+ */
+export declare function vitePluginUserActions({ settings }: {
+    settings: AstroSettings;
+}): VitePlugin;

package/dist/actions/index.js

@@ -2,8 +2,18 @@ import fsMod from "node:fs";
 import { ActionsWithoutServerOutputError } from "../core/errors/errors-data.js";
 import { AstroError } from "../core/errors/errors.js";
 import { isServerLikeOutput, viteID } from "../core/util.js";
-import { ACTIONS_TYPES_FILE, RESOLVED_VIRTUAL_MODULE_ID, VIRTUAL_MODULE_ID } from "./consts.js";
-function astroActions({ fs = fsMod }) {
+import {
+  ACTIONS_TYPES_FILE,
+  NOOP_ACTIONS,
+  RESOLVED_VIRTUAL_INTERNAL_MODULE_ID,
+  RESOLVED_VIRTUAL_MODULE_ID,
+  VIRTUAL_INTERNAL_MODULE_ID,
+  VIRTUAL_MODULE_ID
+} from "./consts.js";
+function astroActions({
+  fs = fsMod,
+  settings
+}) {
   return {
     name: VIRTUAL_MODULE_ID,
     hooks: {
@@ -18,10 +28,7 @@ function astroActions({ fs = fsMod }) {
         );
         params.updateConfig({
           vite: {
-            define: {
-              "import.meta.env.ACTIONS_PATH": stringifiedActionsImport
-            },
-            plugins: [vitePluginActions(fs)]
+            plugins: [vitePluginUserActions({ settings }), vitePluginActions(fs)]
           }
         });
         params.injectRoute({
@@ -42,6 +49,34 @@ function astroActions({ fs = fsMod }) {
     }
   };
 }
+function vitePluginUserActions({ settings }) {
+  let resolvedActionsId;
+  return {
+    name: "@astro/plugin-actions",
+    async resolveId(id) {
+      if (id === NOOP_ACTIONS) {
+        return NOOP_ACTIONS;
+      }
+      if (id === VIRTUAL_INTERNAL_MODULE_ID) {
+        const resolvedModule = await this.resolve(
+          `${decodeURI(new URL("actions", settings.config.srcDir).pathname)}`
+        );
+        if (!resolvedModule) {
+          return NOOP_ACTIONS;
+        }
+        resolvedActionsId = resolvedModule.id;
+        return RESOLVED_VIRTUAL_INTERNAL_MODULE_ID;
+      }
+    },
+    load(id) {
+      if (id === NOOP_ACTIONS) {
+        return "export const server = {}";
+      } else if (id === RESOLVED_VIRTUAL_INTERNAL_MODULE_ID) {
+        return `export { server } from '${resolvedActionsId}';`;
+      }
+    }
+  };
+}
 const vitePluginActions = (fs) => ({
   name: VIRTUAL_MODULE_ID,
   enforce: "pre",
@@ -81,5 +116,6 @@ async function typegen({
   await fs.promises.writeFile(new URL(ACTIONS_TYPES_FILE, dotAstroDir), content);
 }
 export {
-  astroActions as default
+  astroActions as default,
+  vitePluginUserActions
 };

package/dist/actions/runtime/middleware.js

@@ -1,49 +1,106 @@
 import { yellow } from "kleur/colors";
+import {
+  ActionQueryStringInvalidError,
+  ActionsUsedWithForGetError
+} from "../../core/errors/errors-data.js";
+import { AstroError } from "../../core/errors/errors.js";
 import { defineMiddleware } from "../../core/middleware/index.js";
 import { ApiContextStorage } from "./store.js";
 import { formContentTypes, getAction, hasContentType } from "./utils.js";
-import { callSafely } from "./virtual/shared.js";
+import { getActionQueryString } from "./virtual/shared.js";
 const onRequest = defineMiddleware(async (context, next) => {
   const locals = context.locals;
+  const { request } = context;
   if (locals._actionsInternal) return ApiContextStorage.run(context, () => next());
-  if (context.request.method === "GET") {
-    return nextWithLocalsStub(next, context);
-  }
-  if (context.request.method === "POST" && context.request.body === null) {
+  if (request.method === "POST" && request.body === null) {
     return nextWithStaticStub(next, context);
   }
-  const { request, url } = context;
-  const contentType = request.headers.get("Content-Type");
-  if (url.pathname.startsWith("/_actions")) return nextWithLocalsStub(next, context);
-  if (!contentType || !hasContentType(contentType, formContentTypes)) {
-    return nextWithLocalsStub(next, context);
+  const actionName = context.url.searchParams.get("_astroAction");
+  if (context.request.method === "POST" && actionName) {
+    return handlePost({ context, next, actionName });
+  }
+  if (context.request.method === "GET" && actionName) {
+    throw new AstroError({
+      ...ActionsUsedWithForGetError,
+      message: ActionsUsedWithForGetError.message(actionName)
+    });
   }
-  const formData = await request.clone().formData();
-  const actionPath = formData.get("_astroAction");
-  if (typeof actionPath !== "string") return nextWithLocalsStub(next, context);
-  const action = await getAction(actionPath);
-  if (!action) return nextWithLocalsStub(next, context);
-  const result = await ApiContextStorage.run(context, () => callSafely(() => action(formData)));
+  if (context.request.method === "POST") {
+    return handlePostLegacy({ context, next });
+  }
+  return nextWithLocalsStub(next, context);
+});
+async function handlePost({
+  context,
+  next,
+  actionName
+}) {
+  const { request } = context;
+  const action = await getAction(actionName);
+  if (!action) {
+    throw new AstroError({
+      ...ActionQueryStringInvalidError,
+      message: ActionQueryStringInvalidError.message(actionName)
+    });
+  }
+  const contentType = request.headers.get("content-type");
+  let formData;
+  if (contentType && hasContentType(contentType, formContentTypes)) {
+    formData = await request.clone().formData();
+  }
+  const actionResult = await ApiContextStorage.run(context, () => action(formData));
+  return handleResult({ context, next, actionName, actionResult });
+}
+function handleResult({
+  context,
+  next,
+  actionName,
+  actionResult
+}) {
   const actionsInternal = {
     getActionResult: (actionFn) => {
-      if (actionFn.toString() !== actionPath) return Promise.resolve(void 0);
-      return result;
+      if (actionFn.toString() !== getActionQueryString(actionName)) {
+        return Promise.resolve(void 0);
+      }
+      return actionResult;
     },
-    actionResult: result
+    actionResult
   };
+  const locals = context.locals;
   Object.defineProperty(locals, "_actionsInternal", { writable: false, value: actionsInternal });
   return ApiContextStorage.run(context, async () => {
     const response = await next();
-    if (result.error) {
+    if (actionResult.error) {
       return new Response(response.body, {
-        status: result.error.status,
-        statusText: result.error.name,
+        status: actionResult.error.status,
+        statusText: actionResult.error.type,
         headers: response.headers
       });
     }
     return response;
   });
-});
+}
+async function handlePostLegacy({ context, next }) {
+  const { request } = context;
+  if (context.url.pathname.startsWith("/_actions")) return nextWithLocalsStub(next, context);
+  const contentType = request.headers.get("content-type");
+  let formData;
+  if (contentType && hasContentType(contentType, formContentTypes)) {
+    formData = await request.clone().formData();
+  }
+  if (!formData) return nextWithLocalsStub(next, context);
+  const actionName = formData.get("_astroAction");
+  if (!actionName) return nextWithLocalsStub(next, context);
+  const action = await getAction(actionName);
+  if (!action) {
+    throw new AstroError({
+      ...ActionQueryStringInvalidError,
+      message: ActionQueryStringInvalidError.message(actionName)
+    });
+  }
+  const actionResult = await ApiContextStorage.run(context, () => action(formData));
+  return handleResult({ context, next, actionName, actionResult });
+}
 function nextWithStaticStub(next, context) {
   Object.defineProperty(context.locals, "_actionsInternal", {
     writable: false,

package/dist/actions/runtime/route.js

@@ -1,6 +1,5 @@
 import { ApiContextStorage } from "./store.js";
 import { formContentTypes, getAction, hasContentType } from "./utils.js";
-import { callSafely } from "./virtual/shared.js";
 const POST = async (context) => {
   const { request, url } = context;
   const action = await getAction(url.pathname);
@@ -19,7 +18,7 @@ const POST = async (context) => {
   } else {
     return new Response(null, { status: 415 });
   }
-  const result = await ApiContextStorage.run(context, () => callSafely(() => action(args)));
+  const result = await ApiContextStorage.run(context, () => action(args));
   if (result.error) {
     return new Response(
       JSON.stringify({
@@ -36,7 +35,7 @@ const POST = async (context) => {
     );
   }
   return new Response(JSON.stringify(result.data), {
-    status: result.data ? 200 : 204,
+    status: result.data !== void 0 ? 200 : 204,
     headers: {
       "Content-Type": "application/json"
     }

package/dist/actions/runtime/utils.d.ts

@@ -1,12 +1,14 @@
+import type { ZodType } from 'zod';
+import type { ActionAccept, ActionClient } from './virtual/server.js';
 export declare const formContentTypes: string[];
 export declare function hasContentType(contentType: string, expected: string[]): boolean;
 export type MaybePromise<T> = T | Promise<T>;
 /**
  * Get server-side action based on the route path.
- * Imports from `import.meta.env.ACTIONS_PATH`, which maps to
+ * Imports from the virtual module `astro:internal-actions`, which maps to
  * the user's `src/actions/index.ts` file at build-time.
  */
-export declare function getAction(path: string): Promise<((param: unknown) => MaybePromise<unknown>) | undefined>;
+export declare function getAction(path: string): Promise<ActionClient<unknown, ActionAccept, ZodType> | undefined>;
 /**
  * Used to preserve the input schema type in the error object.
  * This allows for type inference on the `fields` property

package/dist/actions/runtime/utils.js

@@ -5,7 +5,7 @@ function hasContentType(contentType, expected) {
 }
 async function getAction(path) {
   const pathKeys = path.replace("/_actions/", "").split(".");
-  let { server: actionLookup } = await import(import.meta.env.ACTIONS_PATH);
+  let { server: actionLookup } = await import("astro:internal-actions");
   for (const key of pathKeys) {
     if (!(key in actionLookup)) {
       return void 0;

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

@@ -10,15 +10,16 @@ export type ActionAccept = 'form' | 'json';
 export type ActionInputSchema<T extends ActionAccept | undefined> = T extends 'form' ? z.AnyZodObject | z.ZodType<FormData> : z.ZodType;
 export type ActionHandler<TInputSchema, TOutput> = TInputSchema extends z.ZodType ? (input: z.infer<TInputSchema>, context: ActionAPIContext) => MaybePromise<TOutput> : (input: any, context: ActionAPIContext) => MaybePromise<TOutput>;
 export type ActionReturnType<T extends ActionHandler<any, any>> = Awaited<ReturnType<T>>;
-export type ActionClient<TOutput, TAccept extends ActionAccept | undefined, TInputSchema extends ActionInputSchema<TAccept> | undefined> = TInputSchema extends z.ZodType ? ((input: TAccept extends 'form' ? FormData : z.input<TInputSchema>) => Promise<Awaited<TOutput>>) & {
-    safe: (input: TAccept extends 'form' ? FormData : z.input<TInputSchema>) => Promise<SafeResult<z.input<TInputSchema> extends ErrorInferenceObject ? z.input<TInputSchema> : ErrorInferenceObject, Awaited<TOutput>>>;
-} : ((input?: any) => Promise<Awaited<TOutput>>) & {
-    safe: (input?: any) => Promise<SafeResult<never, Awaited<TOutput>>>;
+export type ActionClient<TOutput, TAccept extends ActionAccept | undefined, TInputSchema extends ActionInputSchema<TAccept> | undefined> = TInputSchema extends z.ZodType ? ((input: TAccept extends 'form' ? FormData : z.input<TInputSchema>) => Promise<SafeResult<z.input<TInputSchema> extends ErrorInferenceObject ? z.input<TInputSchema> : ErrorInferenceObject, Awaited<TOutput>>>) & {
+    queryString: string;
+    orThrow: (input: TAccept extends 'form' ? FormData : z.input<TInputSchema>) => Promise<Awaited<TOutput>>;
+} : (input?: any) => Promise<SafeResult<never, Awaited<TOutput>>> & {
+    orThrow: (input?: any) => Promise<Awaited<TOutput>>;
 };
 export declare function defineAction<TOutput, TAccept extends ActionAccept | undefined = undefined, TInputSchema extends ActionInputSchema<ActionAccept> | undefined = TAccept extends 'form' ? z.ZodType<FormData> : undefined>({ accept, input: inputSchema, handler, }: {
     input?: TInputSchema;
     accept?: TAccept;
     handler: ActionHandler<TInputSchema, TOutput>;
-}): ActionClient<TOutput, TAccept, TInputSchema>;
+}): ActionClient<TOutput, TAccept, TInputSchema> & string;
 /** Transform form data to an object based on a Zod schema. */
 export declare function formDataToObject<T extends z.AnyZodObject>(formData: FormData, schema: T): Record<string, unknown>;

package/dist/actions/runtime/virtual/server.js

@@ -10,12 +10,13 @@ function defineAction({
   handler
 }) {
   const serverHandler = accept === "form" ? getFormServerHandler(handler, inputSchema) : getJsonServerHandler(handler, inputSchema);
-  Object.assign(serverHandler, {
-    safe: async (unparsedInput) => {
-      return callSafely(() => serverHandler(unparsedInput));
-    }
+  const safeServerHandler = async (unparsedInput) => {
+    return callSafely(() => serverHandler(unparsedInput));
+  };
+  Object.assign(safeServerHandler, {
+    orThrow: serverHandler
   });
-  return serverHandler;
+  return safeServerHandler;
 }
 function getFormServerHandler(handler, inputSchema) {
   return async (unparsedInput) => {

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

@@ -31,6 +31,13 @@ export declare class ActionInputError<T extends ErrorInferenceObject> extends Ac
     constructor(issues: z.ZodIssue[]);
 }
 export declare function callSafely<TOutput>(handler: () => MaybePromise<TOutput>): Promise<SafeResult<z.ZodType, TOutput>>;
+export declare function getActionQueryString(name: string): string;
+/**
+ * @deprecated You can now pass action functions
+ * directly to the `action` attribute on a form.
+ *
+ * Example: `<form action={actions.like} />`
+ */
 export declare function getActionProps<T extends (args: FormData) => MaybePromise<unknown>>(action: T): {
     readonly type: "hidden";
     readonly name: "_astroAction";

package/dist/actions/runtime/virtual/shared.js

@@ -110,11 +110,20 @@ async function callSafely(handler) {
     };
   }
 }
+function getActionQueryString(name) {
+  const searchParams = new URLSearchParams({ _astroAction: name });
+  return `?${searchParams.toString()}`;
+}
 function getActionProps(action) {
+  const params = new URLSearchParams(action.toString());
+  const actionName = params.get("_astroAction");
+  if (!actionName) {
+    throw new Error("Invalid actions function was passed to getActionProps()");
+  }
   return {
     type: "hidden",
     name: "_astroAction",
-    value: action.toString()
+    value: actionName
   };
 }
 export {
@@ -123,5 +132,6 @@ export {
   ActionInputError,
   callSafely,
   getActionProps,
+  getActionQueryString,
   isInputError
 };

package/dist/cli/add/index.js

@@ -569,7 +569,7 @@ async function resolveRangeToInstallSpecifier(name, range) {
   const versions = await fetchPackageVersions(name);
   if (versions instanceof Error) return name;
   const stableVersions = versions.filter((v) => !v.includes("-"));
-  const maxStable = maxSatisfying(stableVersions, range);
+  const maxStable = maxSatisfying(stableVersions.length !== 0 ? stableVersions : versions, range);
   return `${name}@^${maxStable}`;
 }
 const INHERITED_FLAGS = /* @__PURE__ */ new Set([

package/dist/container/index.js

@@ -15,7 +15,6 @@ function createManifest(manifest, renderers, middleware) {
   };
   return {
     hrefRoot: import.meta.url,
-    rewritingEnabled: false,
     trailingSlash: manifest?.trailingSlash ?? ASTRO_CONFIG_DEFAULTS.trailingSlash,
     buildFormat: manifest?.buildFormat ?? ASTRO_CONFIG_DEFAULTS.build.format,
     compressHTML: manifest?.compressHTML ?? ASTRO_CONFIG_DEFAULTS.compressHTML,

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

@@ -7,5 +7,5 @@ export declare function createImage(pluginContext: PluginContext, shouldEmitFile
     height: number;
     src: string;
     fsPath: string;
-    orientation?: number;
+    orientation?: number | undefined;
 }, string>;

package/dist/content/types-generator.js

@@ -283,7 +283,7 @@ async function writeContentFiles({
   let contentTypesStr = "";
   let dataTypesStr = "";
   const collectionSchemasDir = new URL("./collections/", settings.dotAstroDir);
-  if (settings.config.experimental.contentCollectionJsonSchema && !fs.existsSync(collectionSchemasDir)) {
+  if (!fs.existsSync(collectionSchemasDir)) {
     fs.mkdirSync(collectionSchemasDir, { recursive: true });
   }
   for (const [collection, config] of Object.entries(contentConfig?.collections ?? {})) {
@@ -376,7 +376,7 @@ async function writeContentFiles({
           dataTypesStr += `};
 `;
         }
-        if (settings.config.experimental.contentCollectionJsonSchema && collectionConfig?.schema) {
+        if (collectionConfig?.schema) {
           let zodSchemaForJson = typeof collectionConfig.schema === "function" ? collectionConfig.schema({ image: () => z.string() }) : collectionConfig.schema;
           if (zodSchemaForJson instanceof z.ZodObject) {
             zodSchemaForJson = zodSchemaForJson.extend({
@@ -390,7 +390,9 @@ async function writeContentFiles({
                 zodToJsonSchema(zodSchemaForJson, {
                   name: collectionKey.replace(/"/g, ""),
                   markdownDescription: true,
-                  errorMessages: true
+                  errorMessages: true,
+                  // Fix for https://github.com/StefanTerdell/zod-to-json-schema/issues/110
+                  dateStrategy: ["format:date-time", "format:date", "integer"]
                 }),
                 null,
                 2

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

@@ -92,22 +92,9 @@ function astroContentAssetPropagationPlugin({
   };
 }
 function astroConfigBuildPlugin(options, internals) {
-  let ssrPluginContext = void 0;
   return {
     targets: ["server"],
     hooks: {
-      "build:before": ({ target }) => {
-        return {
-          vitePlugin: {
-            name: "astro:content-build-plugin",
-            generateBundle() {
-              if (target === "server") {
-                ssrPluginContext = this;
-              }
-            }
-          }
-        };
-      },
       "build:post": ({ ssrOutputs, clientOutputs, mutate }) => {
         const outputs = ssrOutputs.flatMap((o) => o.output);
         const prependBase = (src) => {
@@ -187,7 +174,6 @@ function astroConfigBuildPlugin(options, internals) {
             mutate(chunk, ["server"], newCode);
           }
         }
-        ssrPluginContext = void 0;
       }
     }
   };

package/dist/core/app/types.d.ts

@@ -55,7 +55,6 @@ export type SSRManifest = {
     i18n: SSRManifestI18n | undefined;
     middleware: MiddlewareHandler;
     checkOrigin: boolean;
-    rewritingEnabled: boolean;
     experimentalEnvGetSecretEnabled: boolean;
 };
 export type SSRManifestI18n = {