astro 4.13.1 → 4.13.3

package/astro-jsx.d.ts

@@ -14,7 +14,6 @@ declare namespace astroHTML.JSX {
 	export type Children = Child | Child[];
 
 	interface ElementChildrenAttribute {
-		// eslint-disable-next-line @typescript-eslint/ban-types
 		children: {};
 	}
 

package/astro.js

@@ -52,6 +52,7 @@ async function errorNodeUnsupported() {
 Node.js v${process.versions.node} is not supported by Astro!
 Please upgrade Node.js to a supported version: "${engines}"\n`);
 
+	// eslint-disable-next-line @typescript-eslint/no-require-imports
 	const ci = typeof require !== 'undefined' ? require('ci-info') : await import('ci-info');
 
 	// Special instructions for CI environments, which may have special steps needed.
@@ -65,7 +66,7 @@ Please upgrade Node.js to a supported version: "${engines}"\n`);
 			}
 		}
 		console.log(
-			`${ci.name} CI Environment Detected!\nAdditional steps may be needed to set your Node.js version:`
+			`${ci.name} CI Environment Detected!\nAdditional steps may be needed to set your Node.js version:`,
 		);
 		console.log(`Documentation: https://docs.astro.build/en/guides/deploy/`);
 		if (CI_INSTRUCTIONS[platform]) {

package/client.d.ts

@@ -50,7 +50,7 @@ declare module 'astro:assets' {
 		 * This is functionally equivalent to using the `<Image />` component, as the component calls this function internally.
 		 */
 		getImage: (
-			options: import('./dist/assets/types.js').UnresolvedImageTransform
+			options: import('./dist/assets/types.js').UnresolvedImageTransform,
 		) => Promise<import('./dist/assets/types.js').GetImageResult>;
 		imageConfig: import('./dist/@types/astro.js').AstroConfig['image'];
 		getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;

package/components/Picture.astro

@@ -53,8 +53,8 @@ const optimizedImages: GetImageResult[] = await Promise.all(
 				format: format,
 				widths: props.widths,
 				densities: props.densities,
-			})
-	)
+			}),
+	),
 );
 
 let resultFallbackFormat = fallbackFormat ?? defaultFallbackFormat;

package/components/ViewTransitions.astro

@@ -53,7 +53,7 @@ const { fallback = 'animate' } = Astro.props;
 	if (supportsViewTransitions || getFallback() !== 'none') {
 		if (import.meta.env.DEV && window.matchMedia('(prefers-reduced-motion)').matches) {
 			console.warn(
-				`[transitions]: all view transition animations, including fallback animation, are disabled as this device has the prefer-reduced-motion setting enabled.`
+				`[transitions]: all view transition animations, including fallback animation, are disabled as this device has the prefer-reduced-motion setting enabled.`,
 			);
 		}
 		document.addEventListener('click', (ev) => {

package/config.d.ts

@@ -17,7 +17,7 @@ export function defineConfig(config: AstroUserConfig): AstroUserConfig;
  */
 export function getViteConfig(
 	config: ViteUserConfig,
-	inlineAstroConfig?: AstroInlineConfig
+	inlineAstroConfig?: AstroInlineConfig,
 ): ViteUserConfigFn;
 
 /**

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

@@ -1842,25 +1842,29 @@ export interface AstroUserConfig {
          * @version 4.10.0
          * @description
          *
-         * Enables experimental `astro:env` features .
+         * Enables experimental `astro:env` features.
          *
          * The `astro:env` API lets you configure a type-safe schema for your environment variables, and indicate whether they should be available on the server or the client. Import and use your defined variables from the appropriate `/client` or `/server` module:
          *
          * ```astro
          * ---
-         * import { APP_ID } from "astro:env/client"
-         * import { API_URL, API_TOKEN, getSecret } from "astro:env/server"
-         * const NODE_ENV = getSecret("NODE_ENV")
+         * import { API_URL } from "astro:env/client"
+         * import { API_SECRET_TOKEN } from "astro:env/server"
          *
          * const data = await fetch(`${API_URL}/users`, {
-         * 	method: "POST",
+         * 	method: "GET",
          * 	headers: {
          * 		"Content-Type": "application/json",
-         * 		"Authorization": `Bearer ${API_TOKEN}`
+         * 		"Authorization": `Bearer ${API_SECRET_TOKEN}`
          * 	},
-         * 	body: JSON.stringify({ appId: APP_ID, nodeEnv: NODE_ENV })
          * })
          * ---
+         *
+         * <script>
+         * import { API_URL } from "astro:env/client"
+         *
+         * fetch(`${API_URL}/ping`)
+         * </script>
          * ```
          *
          * To define the data type and properties of your environment variables, declare a schema in your Astro config in `experimental.env.schema`. The `envField` helper allows you define your variable as a string, number, or boolean and pass properties in an object:
@@ -1898,7 +1902,7 @@ export interface AstroUserConfig {
          *     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 `astro:env/server` module. The `getSecret()` helper function can be used to retrieve secrets not specified in the schema:
+         * - **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. Its implementation is provided by your adapter and defaults to `process.env`:
          *
          *     ```js
          *     import { API_SECRET, getSecret } from "astro:env/server"

package/dist/actions/consts.d.ts

@@ -4,3 +4,8 @@ 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";
+export declare const ACTION_QUERY_PARAMS: {
+    actionName: string;
+    actionPayload: string;
+    actionRedirect: string;
+};

package/dist/actions/consts.js

@@ -4,8 +4,14 @@ 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";
+const ACTION_QUERY_PARAMS = {
+  actionName: "_astroAction",
+  actionPayload: "_astroActionPayload",
+  actionRedirect: "_astroActionRedirect"
+};
 export {
   ACTIONS_TYPES_FILE,
+  ACTION_QUERY_PARAMS,
   NOOP_ACTIONS,
   RESOLVED_VIRTUAL_INTERNAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,

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

@@ -1,9 +1,9 @@
-import type { APIContext } from '../../@types/astro.js';
+import { type SerializedActionResult } from './virtual/shared.js';
+export type ActionPayload = {
+    actionResult: SerializedActionResult;
+    actionName: string;
+};
 export type Locals = {
-    _actionsInternal: {
-        getActionResult: APIContext['getActionResult'];
-        callAction: APIContext['callAction'];
-        actionResult?: ReturnType<APIContext['getActionResult']>;
-    };
+    _actionPayload: ActionPayload;
 };
 export declare const onRequest: import("../../@types/astro.js").MiddlewareHandler;

package/dist/actions/runtime/middleware.js

@@ -1,37 +1,59 @@
 import { yellow } from "kleur/colors";
-import {
-  ActionQueryStringInvalidError,
-  ActionsUsedWithForGetError
-} from "../../core/errors/errors-data.js";
+import { ActionQueryStringInvalidError } from "../../core/errors/errors-data.js";
 import { AstroError } from "../../core/errors/errors.js";
 import { defineMiddleware } from "../../core/middleware/index.js";
-import { formContentTypes, getAction, hasContentType } from "./utils.js";
-import { getActionQueryString } from "./virtual/shared.js";
+import { ACTION_QUERY_PARAMS } from "../consts.js";
+import { formContentTypes, hasContentType } from "./utils.js";
+import { getAction } from "./virtual/get-action.js";
+import {
+  serializeActionResult
+} from "./virtual/shared.js";
 const onRequest = defineMiddleware(async (context, next) => {
   const locals = context.locals;
   const { request } = context;
-  if (locals._actionsInternal) {
-    locals._actionsInternal.callAction = createCallAction(context);
-    return next();
+  if (locals._actionPayload) return next();
+  const actionPayload = context.cookies.get(ACTION_QUERY_PARAMS.actionPayload)?.json();
+  if (actionPayload) {
+    if (!isActionPayload(actionPayload)) {
+      throw new Error("Internal: Invalid action payload in cookie.");
+    }
+    return renderResult({ context, next, ...actionPayload });
   }
-  if (request.method === "POST" && request.body === null) {
-    return nextWithStaticStub(next, context);
+  if (import.meta.env.DEV && request.method === "POST" && request.body === null) {
+    console.warn(
+      yellow("[astro:actions]"),
+      'POST requests should not be sent to prerendered pages. If you\'re using Actions, disable prerendering with `export const prerender = "false".'
+    );
+    return next();
   }
-  const actionName = context.url.searchParams.get("_astroAction");
+  const actionName = context.url.searchParams.get(ACTION_QUERY_PARAMS.actionName);
   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)
-    });
-  }
   if (context.request.method === "POST") {
     return handlePostLegacy({ context, next });
   }
-  return nextWithLocalsStub(next, context);
+  return next();
 });
+async function renderResult({
+  context,
+  next,
+  actionResult,
+  actionName
+}) {
+  const locals = context.locals;
+  locals._actionPayload = { actionResult, actionName };
+  const response = await next();
+  context.cookies.delete(ACTION_QUERY_PARAMS.actionPayload);
+  if (actionResult.type === "error") {
+    return new Response(response.body, {
+      status: actionResult.status,
+      statusText: actionResult.type,
+      headers: response.headers
+    });
+  }
+  return response;
+}
 async function handlePost({
   context,
   next,
@@ -52,47 +74,45 @@ async function handlePost({
   }
   const action = baseAction.bind(context);
   const actionResult = await action(formData);
-  return handleResult({ context, next, actionName, actionResult });
+  if (context.url.searchParams.get(ACTION_QUERY_PARAMS.actionRedirect) === "false") {
+    return renderResult({
+      context,
+      next,
+      actionName,
+      actionResult: serializeActionResult(actionResult)
+    });
+  }
+  return redirectWithResult({ context, actionName, actionResult });
 }
-async function handleResult({
+async function redirectWithResult({
   context,
-  next,
   actionName,
   actionResult
 }) {
-  const actionsInternal = {
-    getActionResult: (actionFn) => {
-      if (actionFn.toString() !== getActionQueryString(actionName)) {
-        return Promise.resolve(void 0);
-      }
-      return actionResult;
-    },
-    callAction: createCallAction(context),
-    actionResult
-  };
-  const locals = context.locals;
-  Object.defineProperty(locals, "_actionsInternal", { writable: false, value: actionsInternal });
-  const response = await next();
+  context.cookies.set(ACTION_QUERY_PARAMS.actionPayload, {
+    actionName,
+    actionResult: serializeActionResult(actionResult)
+  });
   if (actionResult.error) {
-    return new Response(response.body, {
-      status: actionResult.error.status,
-      statusText: actionResult.error.type,
-      headers: response.headers
-    });
+    const referer = context.request.headers.get("Referer");
+    if (!referer) {
+      throw new Error("Internal: Referer unexpectedly missing from Action POST request.");
+    }
+    return context.redirect(referer);
   }
-  return response;
+  return context.redirect(context.url.pathname);
 }
 async function handlePostLegacy({ context, next }) {
   const { request } = context;
-  if (context.url.pathname.startsWith("/_actions")) return nextWithLocalsStub(next, context);
+  if (context.url.pathname.startsWith("/_actions")) return next();
   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);
+  if (!formData) return next();
+  const actionName = formData.get(ACTION_QUERY_PARAMS.actionName);
+  if (!actionName) return next();
   const baseAction = await getAction(actionName);
   if (!baseAction) {
     throw new AstroError({
@@ -102,39 +122,13 @@ async function handlePostLegacy({ context, next }) {
   }
   const action = baseAction.bind(context);
   const actionResult = await action(formData);
-  return handleResult({ context, next, actionName, actionResult });
-}
-function nextWithStaticStub(next, context) {
-  Object.defineProperty(context.locals, "_actionsInternal", {
-    writable: false,
-    value: {
-      getActionResult: () => {
-        console.warn(
-          yellow("[astro:actions]"),
-          "`getActionResult()` should not be called on prerendered pages. Astro can only handle actions for pages rendered on-demand."
-        );
-        return void 0;
-      },
-      callAction: createCallAction(context)
-    }
-  });
-  return next();
-}
-function nextWithLocalsStub(next, context) {
-  Object.defineProperty(context.locals, "_actionsInternal", {
-    writable: false,
-    value: {
-      getActionResult: () => void 0,
-      callAction: createCallAction(context)
-    }
-  });
-  return next();
+  return redirectWithResult({ context, actionName, actionResult });
 }
-function createCallAction(context) {
-  return (baseAction, input) => {
-    const action = baseAction.bind(context);
-    return action(input);
-  };
+function isActionPayload(json) {
+  if (typeof json !== "object" || json == null) return false;
+  if (!("actionResult" in json) || typeof json.actionResult !== "object") return false;
+  if (!("actionName" in json) || typeof json.actionName !== "string") return false;
+  return true;
 }
 export {
   onRequest

package/dist/actions/runtime/route.js

@@ -1,4 +1,6 @@
-import { formContentTypes, getAction, hasContentType } from "./utils.js";
+import { formContentTypes, hasContentType } from "./utils.js";
+import { getAction } from "./virtual/get-action.js";
+import { serializeActionResult } from "./virtual/shared.js";
 const POST = async (context) => {
   const { request, url } = context;
   const baseAction = await getAction(url.pathname);
@@ -8,7 +10,7 @@ const POST = async (context) => {
   const contentType = request.headers.get("Content-Type");
   const contentLength = request.headers.get("Content-Length");
   let args;
-  if (contentLength === "0") {
+  if (!contentType || contentLength === "0") {
     args = void 0;
   } else if (contentType && hasContentType(contentType, formContentTypes)) {
     args = await request.clone().formData();
@@ -19,25 +21,16 @@ const POST = async (context) => {
   }
   const action = baseAction.bind(context);
   const result = await action(args);
-  if (result.error) {
-    return new Response(
-      JSON.stringify({
-        ...result.error,
-        message: result.error.message,
-        stack: import.meta.env.PROD ? void 0 : result.error.stack
-      }),
-      {
-        status: result.error.status,
-        headers: {
-          "Content-Type": "application/json"
-        }
-      }
-    );
+  const serialized = serializeActionResult(result);
+  if (serialized.type === "empty") {
+    return new Response(null, {
+      status: serialized.status
+    });
   }
-  return new Response(JSON.stringify(result.data), {
-    status: result.data !== void 0 ? 200 : 204,
+  return new Response(serialized.body, {
+    status: serialized.status,
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": serialized.contentType
     }
   });
 };

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

@@ -1,16 +1,8 @@
-import type { ZodType } from 'zod';
 import type { APIContext } from '../../@types/astro.js';
-import type { ActionAccept, ActionClient } from './virtual/server.js';
 export declare const formContentTypes: string[];
 export declare function hasContentType(contentType: string, expected: string[]): boolean;
 export type ActionAPIContext = Omit<APIContext, 'getActionResult' | 'callAction' | 'props'>;
 export type MaybePromise<T> = T | Promise<T>;
-/**
- * Get server-side action based on the route path.
- * 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<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

@@ -3,22 +3,7 @@ function hasContentType(contentType, expected) {
   const type = contentType.split(";")[0].toLowerCase();
   return expected.some((t) => type === t);
 }
-async function getAction(path) {
-  const pathKeys = path.replace("/_actions/", "").split(".");
-  let { server: actionLookup } = await import("astro:internal-actions");
-  for (const key of pathKeys) {
-    if (!(key in actionLookup)) {
-      return void 0;
-    }
-    actionLookup = actionLookup[key];
-  }
-  if (typeof actionLookup !== "function") {
-    return void 0;
-  }
-  return actionLookup;
-}
 export {
   formContentTypes,
-  getAction,
   hasContentType
 };

package/dist/actions/runtime/virtual/get-action.d.ts

@@ -0,0 +1,8 @@
+import type { ZodType } from 'zod';
+import type { ActionAccept, ActionClient } from './server.js';
+/**
+ * Get server-side action based on the route path.
+ * 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<ActionClient<unknown, ActionAccept, ZodType> | undefined>;

package/dist/actions/runtime/virtual/get-action.js

@@ -0,0 +1,17 @@
+async function getAction(path) {
+  const pathKeys = path.replace("/_actions/", "").split(".");
+  let { server: actionLookup } = await import("astro:internal-actions");
+  for (const key of pathKeys) {
+    if (!(key in actionLookup)) {
+      return void 0;
+    }
+    actionLookup = actionLookup[key];
+  }
+  if (typeof actionLookup !== "function") {
+    return void 0;
+  }
+  return actionLookup;
+}
+export {
+  getAction
+};

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

@@ -10,7 +10,7 @@ export type ActionReturnType<T extends ActionHandler<any, any>> = Awaited<Return
 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>>> & {
+} : ((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, }: {

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

@@ -1,5 +1,10 @@
 import type { z } from 'zod';
 import type { ErrorInferenceObject, MaybePromise } from '../utils.js';
+export declare const ACTION_QUERY_PARAMS: {
+    actionName: string;
+    actionPayload: string;
+    actionRedirect: string;
+};
 export declare const ACTION_ERROR_CODES: readonly ["BAD_REQUEST", "UNAUTHORIZED", "FORBIDDEN", "NOT_FOUND", "TIMEOUT", "CONFLICT", "PRECONDITION_FAILED", "PAYLOAD_TOO_LARGE", "UNSUPPORTED_MEDIA_TYPE", "UNPROCESSABLE_CONTENT", "TOO_MANY_REQUESTS", "CLIENT_CLOSED_REQUEST", "INTERNAL_SERVER_ERROR"];
 export type ActionErrorCode = (typeof ACTION_ERROR_CODES)[number];
 export declare class ActionError<T extends ErrorInferenceObject = ErrorInferenceObject> extends Error {
@@ -13,8 +18,9 @@ export declare class ActionError<T extends ErrorInferenceObject = ErrorInference
     });
     static codeToStatus(code: ActionErrorCode): number;
     static statusToCode(status: number): ActionErrorCode;
-    static fromResponse(res: Response): Promise<ActionError<ErrorInferenceObject>>;
+    static fromJson(body: any): ActionError<ErrorInferenceObject>;
 }
+export declare function isActionError(error?: unknown): error is ActionError;
 export declare function isInputError<T extends ErrorInferenceObject>(error?: ActionError<T>): error is ActionInputError<T>;
 export declare function isInputError(error?: unknown): error is ActionInputError<ErrorInferenceObject>;
 export type SafeResult<TInput extends ErrorInferenceObject, TOutput> = {
@@ -43,3 +49,19 @@ export declare function getActionProps<T extends (args: FormData) => MaybePromis
     readonly name: "_astroAction";
     readonly value: string;
 };
+export type SerializedActionResult = {
+    type: 'data';
+    contentType: 'application/json+devalue';
+    status: 200;
+    body: string;
+} | {
+    type: 'error';
+    contentType: 'application/json';
+    status: number;
+    body: string;
+} | {
+    type: 'empty';
+    status: 204;
+};
+export declare function serializeActionResult(res: SafeResult<any, any>): SerializedActionResult;
+export declare function deserializeActionResult(res: SerializedActionResult): SafeResult<any, any>;

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

@@ -1,3 +1,6 @@
+import { parse as devalueParse, stringify as devalueStringify } from "devalue";
+import { ACTION_QUERY_PARAMS as _ACTION_QUERY_PARAMS } from "../../consts.js";
+const ACTION_QUERY_PARAMS = _ACTION_QUERY_PARAMS;
 const ACTION_ERROR_CODES = [
   "BAD_REQUEST",
   "UNAUTHORIZED",
@@ -53,22 +56,23 @@ class ActionError extends Error {
   static statusToCode(status) {
     return statusToCodeMap[status] ?? "INTERNAL_SERVER_ERROR";
   }
-  static async fromResponse(res) {
-    const body = await res.clone().json();
-    if (typeof body === "object" && body?.type === "AstroActionInputError" && Array.isArray(body.issues)) {
+  static fromJson(body) {
+    if (isInputError(body)) {
       return new ActionInputError(body.issues);
     }
-    if (typeof body === "object" && body?.type === "AstroActionError") {
+    if (isActionError(body)) {
       return new ActionError(body);
     }
     return new ActionError({
-      message: res.statusText,
-      code: ActionError.statusToCode(res.status)
+      code: "INTERNAL_SERVER_ERROR"
     });
   }
 }
+function isActionError(error) {
+  return typeof error === "object" && error != null && "type" in error && error.type === "AstroActionError";
+}
 function isInputError(error) {
-  return error instanceof ActionInputError;
+  return typeof error === "object" && error != null && "type" in error && error.type === "AstroActionInputError" && "issues" in error && Array.isArray(error.issues);
 }
 class ActionInputError extends ActionError {
   type = "AstroActionInputError";
@@ -111,7 +115,7 @@ async function callSafely(handler) {
   }
 }
 function getActionQueryString(name) {
-  const searchParams = new URLSearchParams({ _astroAction: name });
+  const searchParams = new URLSearchParams({ [_ACTION_QUERY_PARAMS.actionName]: name });
   return `?${searchParams.toString()}`;
 }
 function getActionProps(action) {
@@ -126,12 +130,59 @@ function getActionProps(action) {
     value: actionName
   };
 }
+function serializeActionResult(res) {
+  if (res.error) {
+    return {
+      type: "error",
+      status: res.error.status,
+      contentType: "application/json",
+      body: JSON.stringify({
+        ...res.error,
+        message: res.error.message,
+        stack: import.meta.env.PROD ? void 0 : res.error.stack
+      })
+    };
+  }
+  if (res.data === void 0) {
+    return {
+      type: "empty",
+      status: 204
+    };
+  }
+  return {
+    type: "data",
+    status: 200,
+    contentType: "application/json+devalue",
+    body: devalueStringify(res.data, {
+      // Add support for URL objects
+      URL: (value) => value instanceof URL && value.href
+    })
+  };
+}
+function deserializeActionResult(res) {
+  if (res.type === "error") {
+    return { error: ActionError.fromJson(JSON.parse(res.body)), data: void 0 };
+  }
+  if (res.type === "empty") {
+    return { data: void 0, error: void 0 };
+  }
+  return {
+    data: devalueParse(res.body, {
+      URL: (href) => new URL(href)
+    }),
+    error: void 0
+  };
+}
 export {
   ACTION_ERROR_CODES,
+  ACTION_QUERY_PARAMS,
   ActionError,
   ActionInputError,
   callSafely,
+  deserializeActionResult,
   getActionProps,
   getActionQueryString,
-  isInputError
+  isActionError,
+  isInputError,
+  serializeActionResult
 };

package/dist/actions/utils.d.ts

@@ -1,5 +1,6 @@
 import type { APIContext } from '../@types/astro.js';
 import type { Locals } from './runtime/middleware.js';
-export declare function hasActionsInternal(locals: APIContext['locals']): locals is Locals;
+import { type ActionAPIContext } from './runtime/utils.js';
+export declare function hasActionPayload(locals: APIContext['locals']): locals is Locals;
 export declare function createGetActionResult(locals: APIContext['locals']): APIContext['getActionResult'];
-export declare function createCallAction(locals: APIContext['locals']): APIContext['callAction'];
+export declare function createCallAction(context: ActionAPIContext): APIContext['callAction'];