astro 5.16.5 → 6.0.0-alpha.1

package/dist/actions/runtime/entrypoints/client.js

@@ -0,0 +1,91 @@
+import { shouldAppendTrailingSlash } from "virtual:astro:actions/options";
+import { internalFetchHeaders } from "virtual:astro:adapter-config/client";
+import {
+  ActionError,
+  createActionsProxy,
+  createGetActionPath,
+  deserializeActionResult,
+  getActionPathFromString,
+  getActionQueryString
+} from "../client.js";
+import { ACTION_QUERY_PARAMS } from "../../consts.js";
+import {
+  ActionError as ActionError2,
+  isActionError,
+  isInputError
+} from "../client.js";
+function defineAction() {
+  throw new Error("[astro:actions] `defineAction()` unexpectedly used on the client.");
+}
+function getActionContext() {
+  throw new Error("[astro:actions] `getActionContext()` unexpectedly used on the client.");
+}
+const getActionPath = createGetActionPath({
+  baseUrl: import.meta.env.BASE_URL,
+  shouldAppendTrailingSlash
+});
+const actions = createActionsProxy({
+  handleAction: async (param, path) => {
+    const headers = new Headers();
+    headers.set("Accept", "application/json");
+    for (const [key, value] of Object.entries(internalFetchHeaders)) {
+      headers.set(key, value);
+    }
+    let body = param;
+    if (!(body instanceof FormData)) {
+      try {
+        body = JSON.stringify(param);
+      } catch (e) {
+        throw new ActionError({
+          code: "BAD_REQUEST",
+          message: `Failed to serialize request body to JSON. Full error: ${e.message}`
+        });
+      }
+      if (body) {
+        headers.set("Content-Type", "application/json");
+      } else {
+        headers.set("Content-Length", "0");
+      }
+    }
+    const rawResult = await fetch(
+      getActionPathFromString({
+        baseUrl: import.meta.env.BASE_URL,
+        shouldAppendTrailingSlash,
+        path: getActionQueryString(path)
+      }),
+      {
+        method: "POST",
+        body,
+        headers
+      }
+    );
+    if (rawResult.status === 204) {
+      return deserializeActionResult({ type: "empty", status: 204 });
+    }
+    const bodyText = await rawResult.text();
+    if (rawResult.ok) {
+      return deserializeActionResult({
+        type: "data",
+        body: bodyText,
+        status: 200,
+        contentType: "application/json+devalue"
+      });
+    }
+    return deserializeActionResult({
+      type: "error",
+      body: bodyText,
+      status: rawResult.status,
+      contentType: "application/json"
+    });
+  }
+});
+export {
+  ACTION_QUERY_PARAMS,
+  ActionError2 as ActionError,
+  actions,
+  defineAction,
+  getActionContext,
+  getActionPath,
+  isActionError,
+  isInputError
+};

package/dist/actions/runtime/entrypoints/route.d.ts

@@ -0,0 +1,2 @@
+import type { APIRoute } from '../../../types/public/common.js';
+export declare const POST: APIRoute;

package/dist/actions/runtime/{route.js → entrypoints/route.js}

@@ -1,4 +1,4 @@
-import { getActionContext } from "./server.js";
+import { getActionContext } from "../server.js";
 const POST = async (context) => {
   const { action, serializeActionResult } = getActionContext(context);
   if (action?.calledFrom !== "rpc") {

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

@@ -0,0 +1,6 @@
+export { ACTION_QUERY_PARAMS } from '../../consts.js';
+export { ActionError, isActionError, isInputError } from '../client.js';
+export { defineAction, getActionContext } from '../server.js';
+export type { ActionAPIContext, ActionClient, ActionErrorCode, ActionInputSchema, ActionReturnType, SafeResult, } from '../types.js';
+export declare const getActionPath: (action: import("../types.js").ActionClient<any, any, any>) => string;
+export declare const actions: Record<string | symbol, any>;

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

@@ -0,0 +1,33 @@
+import { pipelineSymbol } from "../../../core/constants.js";
+import { ActionCalledFromServerError } from "../../../core/errors/errors-data.js";
+import { AstroError } from "../../../core/errors/errors.js";
+import { createGetActionPath, createActionsProxy } from "../client.js";
+import { shouldAppendTrailingSlash } from "virtual:astro:actions/options";
+import { ACTION_QUERY_PARAMS } from "../../consts.js";
+import { ActionError, isActionError, isInputError } from "../client.js";
+import { defineAction, getActionContext } from "../server.js";
+const getActionPath = createGetActionPath({
+  baseUrl: import.meta.env.BASE_URL,
+  shouldAppendTrailingSlash
+});
+const actions = createActionsProxy({
+  handleAction: async (param, path, context) => {
+    const pipeline = context ? Reflect.get(context, pipelineSymbol) : void 0;
+    if (!pipeline) {
+      throw new AstroError(ActionCalledFromServerError);
+    }
+    const action = await pipeline.getAction(path);
+    if (!action) throw new Error(`Action not found: ${path}`);
+    return action.bind(context)(param);
+  }
+});
+export {
+  ACTION_QUERY_PARAMS,
+  ActionError,
+  actions,
+  defineAction,
+  getActionContext,
+  getActionPath,
+  isActionError,
+  isInputError
+};

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

@@ -1,36 +1,13 @@
-import { z } from 'zod';
+import * as z from 'zod/v4/core';
 import type { APIContext } from '../../types/public/index.js';
-import { deserializeActionResult, type SafeResult, type SerializedActionResult, serializeActionResult } from './shared.js';
-import { type ActionAPIContext, type ErrorInferenceObject, type MaybePromise } from './utils.js';
-export * from './shared.js';
-export type ActionAccept = 'form' | 'json';
-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 InferKey = '__internalInfer';
-/**
- * Infers the type of an action's input based on its Zod schema
- *
- * @see https://docs.astro.build/en/reference/modules/astro-actions/#actioninputschema
- */
-export type ActionInputSchema<T extends ActionClient<any, any, any>> = T extends {
-    [key in InferKey]: any;
-} ? T[InferKey] : never;
-export type ActionClient<TOutput, TAccept extends ActionAccept | undefined, TInputSchema extends z.ZodType | 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>>;
-} & {
-    [key in InferKey]: TInputSchema;
-} : ((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 z.ZodType | undefined = TAccept extends 'form' ? z.ZodType<FormData> : undefined>({ accept, input: inputSchema, handler, }: {
+import { deserializeActionResult } from './client.js';
+import type { ActionAccept, ActionClient, ActionHandler, SafeResult, SerializedActionResult } from './types.js';
+export declare function defineAction<TOutput, TAccept extends ActionAccept | undefined = undefined, TInputSchema extends z.$ZodType | undefined = TAccept extends 'form' ? z.$ZodType<FormData> : undefined>({ accept, input: inputSchema, handler, }: {
     input?: TInputSchema;
     accept?: TAccept;
     handler: ActionHandler<TInputSchema, TOutput>;
 }): 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>;
-export type AstroActionContext = {
+interface AstroActionContext {
     /** Information about an incoming action request. */
     action?: {
         /** Whether an action was called using an RPC function or by using an HTML form action. */
@@ -54,8 +31,13 @@ export type AstroActionContext = {
      * Deserialize an action result to access data and error objects.
      */
     deserializeActionResult: typeof deserializeActionResult;
-};
+}
 /**
  * Access information about Action requests from middleware.
  */
 export declare function getActionContext(context: APIContext): AstroActionContext;
+export declare const ACTION_API_CONTEXT_SYMBOL: unique symbol;
+/** Transform form data to an object based on a Zod schema. */
+export declare function formDataToObject<T extends z.$ZodObject>(formData: FormData, schema: T): Record<string, unknown>;
+export declare function serializeActionResult(res: SafeResult<any, any>): SerializedActionResult;
+export {};

package/dist/actions/runtime/server.js

@@ -1,25 +1,21 @@
-import { z } from "zod";
+import { stringify as devalueStringify } from "devalue";
+import * as z from "zod/v4/core";
 import { shouldAppendForwardSlash } from "../../core/build/util.js";
+import { pipelineSymbol, REDIRECT_STATUS_CODES } from "../../core/constants.js";
+import {
+  ActionCalledFromServerError,
+  ActionNotFoundError,
+  ActionsReturnedInvalidDataError
+} from "../../core/errors/errors-data.js";
 import { AstroError } from "../../core/errors/errors.js";
-import { ActionCalledFromServerError, ActionNotFoundError } from "../../core/errors/errors-data.js";
 import { removeTrailingForwardSlash } from "../../core/path.js";
-import { apiContextRoutesSymbol } from "../../core/render-context.js";
-import { ACTION_RPC_ROUTE_PATTERN } from "../consts.js";
+import { ACTION_QUERY_PARAMS, ACTION_RPC_ROUTE_PATTERN } from "../consts.js";
 import {
-  ACTION_QUERY_PARAMS,
   ActionError,
   ActionInputError,
-  callSafely,
-  deserializeActionResult,
-  serializeActionResult
-} from "./shared.js";
-import {
-  ACTION_API_CONTEXT_SYMBOL,
-  formContentTypes,
-  hasContentType,
-  isActionAPIContext
-} from "./utils.js";
-export * from "./shared.js";
+  actionResultErrorStack,
+  deserializeActionResult
+} from "./client.js";
 function defineAction({
   accept,
   input: inputSchema,
@@ -51,16 +47,19 @@ function getFormServerHandler(handler, inputSchema) {
       });
     }
     if (!inputSchema) return await handler(unparsedInput, context);
-    const baseSchema = unwrapBaseObjectSchema(inputSchema, unparsedInput);
-    const parsed = await inputSchema.safeParseAsync(
-      baseSchema instanceof z.ZodObject ? formDataToObject(unparsedInput, baseSchema) : unparsedInput
-    );
+    const parsed = await parseFormInput(inputSchema, unparsedInput);
     if (!parsed.success) {
       throw new ActionInputError(parsed.error.issues);
     }
     return await handler(parsed.data, context);
   };
 }
+async function parseFormInput(inputSchema, unparsedInput) {
+  const baseSchema = unwrapBaseZ4ObjectSchema(inputSchema, unparsedInput);
+  const input = baseSchema instanceof z.$ZodObject ? formDataToObject(unparsedInput, baseSchema) : unparsedInput;
+  const parsed = await z.safeParseAsync(inputSchema, input);
+  return parsed;
+}
 function getJsonServerHandler(handler, inputSchema) {
   return async (unparsedInput, context) => {
     if (unparsedInput instanceof FormData) {
@@ -70,72 +69,13 @@ function getJsonServerHandler(handler, inputSchema) {
       });
     }
     if (!inputSchema) return await handler(unparsedInput, context);
-    const parsed = await inputSchema.safeParseAsync(unparsedInput);
+    const parsed = await z.safeParseAsync(inputSchema, unparsedInput);
     if (!parsed.success) {
       throw new ActionInputError(parsed.error.issues);
     }
     return await handler(parsed.data, context);
   };
 }
-function formDataToObject(formData, schema) {
-  const obj = schema._def.unknownKeys === "passthrough" ? Object.fromEntries(formData.entries()) : {};
-  for (const [key, baseValidator] of Object.entries(schema.shape)) {
-    let validator = baseValidator;
-    while (validator instanceof z.ZodOptional || validator instanceof z.ZodNullable || validator instanceof z.ZodDefault) {
-      if (validator instanceof z.ZodDefault && !formData.has(key)) {
-        obj[key] = validator._def.defaultValue();
-      }
-      validator = validator._def.innerType;
-    }
-    if (!formData.has(key) && key in obj) {
-      continue;
-    } else if (validator instanceof z.ZodBoolean) {
-      const val = formData.get(key);
-      obj[key] = val === "true" ? true : val === "false" ? false : formData.has(key);
-    } else if (validator instanceof z.ZodArray) {
-      obj[key] = handleFormDataGetAll(key, formData, validator);
-    } else {
-      obj[key] = handleFormDataGet(key, formData, validator, baseValidator);
-    }
-  }
-  return obj;
-}
-function handleFormDataGetAll(key, formData, validator) {
-  const entries = Array.from(formData.getAll(key));
-  const elementValidator = validator._def.type;
-  if (elementValidator instanceof z.ZodNumber) {
-    return entries.map(Number);
-  } else if (elementValidator instanceof z.ZodBoolean) {
-    return entries.map(Boolean);
-  }
-  return entries;
-}
-function handleFormDataGet(key, formData, validator, baseValidator) {
-  const value = formData.get(key);
-  if (!value) {
-    return baseValidator instanceof z.ZodOptional ? void 0 : null;
-  }
-  return validator instanceof z.ZodNumber ? Number(value) : value;
-}
-function unwrapBaseObjectSchema(schema, unparsedInput) {
-  while (schema instanceof z.ZodEffects || schema instanceof z.ZodPipeline) {
-    if (schema instanceof z.ZodEffects) {
-      schema = schema._def.schema;
-    }
-    if (schema instanceof z.ZodPipeline) {
-      schema = schema._def.in;
-    }
-  }
-  if (schema instanceof z.ZodDiscriminatedUnion) {
-    const typeKey = schema._def.discriminator;
-    const typeValue = unparsedInput.get(typeKey);
-    if (typeof typeValue !== "string") return schema;
-    const objSchema = schema._def.optionsMap.get(typeValue);
-    if (!objSchema) return schema;
-    return objSchema;
-  }
-  return schema;
-}
 function getActionContext(context) {
   const callerInfo = getCallerInfo(context);
   const actionResultAlreadySet = Boolean(context.locals._actionPayload);
@@ -145,7 +85,7 @@ function getActionContext(context) {
       calledFrom: callerInfo.from,
       name: callerInfo.name,
       handler: async () => {
-        const pipeline = Reflect.get(context, apiContextRoutesSymbol);
+        const pipeline = Reflect.get(context, pipelineSymbol);
         const callerInfoName = shouldAppendForwardSlash(
           pipeline.manifest.trailingSlash,
           pipeline.manifest.buildFormat
@@ -218,8 +158,148 @@ async function parseRequestBody(request) {
   }
   throw new TypeError("Unsupported content type");
 }
+const ACTION_API_CONTEXT_SYMBOL = Symbol.for("astro.actionAPIContext");
+const formContentTypes = ["application/x-www-form-urlencoded", "multipart/form-data"];
+function hasContentType(contentType, expected) {
+  const type = contentType.split(";")[0].toLowerCase();
+  return expected.some((t) => type === t);
+}
+function isActionAPIContext(ctx) {
+  const symbol = Reflect.get(ctx, ACTION_API_CONTEXT_SYMBOL);
+  return symbol === true;
+}
+function formDataToObject(formData, schema) {
+  const obj = schema._zod.def.catchall ? Object.fromEntries(formData.entries()) : {};
+  for (const [key, baseValidator] of Object.entries(schema._zod.def.shape)) {
+    let validator = baseValidator;
+    while (validator instanceof z.$ZodOptional || validator instanceof z.$ZodNullable || validator instanceof z.$ZodDefault) {
+      if (validator instanceof z.$ZodDefault && !formData.has(key)) {
+        obj[key] = validator._zod.def.defaultValue instanceof Function ? validator._zod.def.defaultValue() : validator._zod.def.defaultValue;
+      }
+      validator = validator._zod.def.innerType;
+    }
+    if (!formData.has(key) && key in obj) {
+      continue;
+    } else if (validator instanceof z.$ZodBoolean) {
+      const val = formData.get(key);
+      obj[key] = val === "true" ? true : val === "false" ? false : formData.has(key);
+    } else if (validator instanceof z.$ZodArray) {
+      obj[key] = handleFormDataGetAll(key, formData, validator);
+    } else {
+      obj[key] = handleFormDataGet(key, formData, validator, baseValidator);
+    }
+  }
+  return obj;
+}
+function handleFormDataGetAll(key, formData, validator) {
+  const entries = Array.from(formData.getAll(key));
+  const elementValidator = validator._zod.def.element;
+  if (elementValidator instanceof z.$ZodNumber) {
+    return entries.map(Number);
+  } else if (elementValidator instanceof z.$ZodBoolean) {
+    return entries.map(Boolean);
+  }
+  return entries;
+}
+function handleFormDataGet(key, formData, validator, baseValidator) {
+  const value = formData.get(key);
+  if (!value) {
+    return baseValidator instanceof z.$ZodOptional ? void 0 : null;
+  }
+  return validator instanceof z.$ZodNumber ? Number(value) : value;
+}
+function unwrapBaseZ4ObjectSchema(schema, unparsedInput) {
+  if (schema instanceof z.$ZodPipe) {
+    return unwrapBaseZ4ObjectSchema(schema._zod.def.in, unparsedInput);
+  }
+  if (schema instanceof z.$ZodDiscriminatedUnion) {
+    const typeKey = schema._zod.def.discriminator;
+    const typeValue = unparsedInput.get(typeKey);
+    if (typeof typeValue !== "string") return schema;
+    const objSchema = schema._zod.def.options.find(
+      (option) => option.def.shape[typeKey].values.has(typeValue)
+    );
+    if (!objSchema) return schema;
+    return objSchema;
+  }
+  return schema;
+}
+async function callSafely(handler) {
+  try {
+    const data = await handler();
+    return { data, error: void 0 };
+  } catch (e) {
+    if (e instanceof ActionError) {
+      return { data: void 0, error: e };
+    }
+    return {
+      data: void 0,
+      error: new ActionError({
+        message: e instanceof Error ? e.message : "Unknown error",
+        code: "INTERNAL_SERVER_ERROR"
+      })
+    };
+  }
+}
+function serializeActionResult(res) {
+  if (res.error) {
+    if (import.meta.env?.DEV) {
+      actionResultErrorStack.set(res.error.stack);
+    }
+    let body2;
+    if (res.error instanceof ActionInputError) {
+      body2 = {
+        type: res.error.type,
+        issues: res.error.issues,
+        fields: res.error.fields
+      };
+    } else {
+      body2 = {
+        ...res.error,
+        message: res.error.message
+      };
+    }
+    return {
+      type: "error",
+      status: res.error.status,
+      contentType: "application/json",
+      body: JSON.stringify(body2)
+    };
+  }
+  if (res.data === void 0) {
+    return {
+      type: "empty",
+      status: 204
+    };
+  }
+  let body;
+  try {
+    body = devalueStringify(res.data, {
+      // Add support for URL objects
+      URL: (value) => value instanceof URL && value.href
+    });
+  } catch (e) {
+    let hint = ActionsReturnedInvalidDataError.hint;
+    if (res.data instanceof Response) {
+      hint = REDIRECT_STATUS_CODES.includes(res.data.status) ? "If you need to redirect when the action succeeds, trigger a redirect where the action is called. See the Actions guide for server and client redirect examples: https://docs.astro.build/en/guides/actions." : "If you need to return a Response object, try using a server endpoint instead. See https://docs.astro.build/en/guides/endpoints/#server-endpoints-api-routes";
+    }
+    throw new AstroError({
+      ...ActionsReturnedInvalidDataError,
+      message: ActionsReturnedInvalidDataError.message(String(e)),
+      hint
+    });
+  }
+  return {
+    type: "data",
+    status: 200,
+    contentType: "application/json+devalue",
+    body
+  };
+}
 export {
+  ACTION_API_CONTEXT_SYMBOL,
   defineAction,
   formDataToObject,
-  getActionContext
+  getActionContext,
+  serializeActionResult
 };

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

@@ -0,0 +1,64 @@
+import type * as z from 'zod/v4/core';
+import type { APIContext } from '../../types/public/index.js';
+import type { ActionError, codeToStatusMap } from './client.js';
+export type ActionErrorCode = keyof typeof codeToStatusMap;
+export type ActionAccept = 'form' | 'json';
+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>>;
+type InferKey = '__internalInfer';
+/**
+ * Infers the type of an action's input based on its Zod schema
+ *
+ * @see https://docs.astro.build/en/reference/modules/astro-actions/#actioninputschema
+ */
+export type ActionInputSchema<T extends ActionClient<any, any, any>> = T extends {
+    [key in InferKey]: any;
+} ? T[InferKey] : never;
+export type ActionClient<TOutput, TAccept extends ActionAccept | undefined, TInputSchema extends z.$ZodType | 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>>;
+} & {
+    [key in InferKey]: TInputSchema;
+} : ((input?: any) => Promise<SafeResult<never, Awaited<TOutput>>>) & {
+    orThrow: (input?: any) => Promise<Awaited<TOutput>>;
+};
+export type SafeResult<TInput extends ErrorInferenceObject, TOutput> = {
+    data: TOutput;
+    error: undefined;
+} | {
+    data: undefined;
+    error: ActionError<TInput>;
+};
+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 interface ActionsLocals {
+    _actionPayload: {
+        actionResult: SerializedActionResult;
+        actionName: string;
+    };
+}
+export type ActionAPIContext = Pick<APIContext, 'request' | 'url' | 'isPrerendered' | 'locals' | 'clientAddress' | 'cookies' | 'currentLocale' | 'generator' | 'routePattern' | 'site' | 'params' | 'preferredLocale' | 'preferredLocaleList' | 'originPathname' | 'session' | 'csp'>;
+export type MaybePromise<T> = T | Promise<T>;
+/**
+ * Used to preserve the input schema type in the error object.
+ * This allows for type inference on the `fields` property
+ * when type narrowed to an `ActionInputError`.
+ *
+ * Example: Action has an input schema of `{ name: z.string() }`.
+ * When calling the action and checking `isInputError(result.error)`,
+ * `result.error.fields` will be typed with the `name` field.
+ */
+export type ErrorInferenceObject = Record<string, any>;
+export {};

package/dist/actions/utils.d.ts

@@ -1,7 +1,7 @@
 import type fsMod from 'node:fs';
 import type { APIContext } from '../types/public/context.js';
-import { type ActionAPIContext, type Locals } from './runtime/utils.js';
-export declare function hasActionPayload(locals: APIContext['locals']): locals is Locals;
+import type { ActionAPIContext, ActionsLocals } from './runtime/types.js';
+export declare function hasActionPayload(locals: APIContext['locals']): locals is ActionsLocals;
 export declare function createGetActionResult(locals: APIContext['locals']): APIContext['getActionResult'];
 export declare function createCallAction(context: ActionAPIContext): APIContext['callAction'];
 /**

package/dist/actions/utils.js

@@ -1,6 +1,6 @@
 import * as eslexer from "es-module-lexer";
-import { deserializeActionResult, getActionQueryString } from "./runtime/shared.js";
-import { ACTION_API_CONTEXT_SYMBOL } from "./runtime/utils.js";
+import { deserializeActionResult, getActionQueryString } from "./runtime/client.js";
+import { ACTION_API_CONTEXT_SYMBOL } from "./runtime/server.js";
 function hasActionPayload(locals) {
   return "_actionPayload" in locals;
 }

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

@@ -1,27 +1,25 @@
-import { addRollupInput } from "../core/build/add-rollup-input.js";
 import { shouldAppendForwardSlash } from "../core/build/util.js";
 import { getServerOutputDirectory } from "../prerender/utils.js";
 import {
-  ENTRYPOINT_VIRTUAL_MODULE_ID,
+  ACTIONS_ENTRYPOINT_VIRTUAL_MODULE_ID,
+  ACTIONS_RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID,
   OPTIONS_VIRTUAL_MODULE_ID,
-  RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID,
   RESOLVED_NOOP_ENTRYPOINT_VIRTUAL_MODULE_ID,
   RESOLVED_OPTIONS_VIRTUAL_MODULE_ID,
-  RESOLVED_RUNTIME_VIRTUAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
-  RUNTIME_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 } from "./consts.js";
 import { isActionsFilePresent } from "./utils.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 function vitePluginActionsBuild(opts, internals) {
   return {
     name: "@astro/plugin-actions-build",
-    options(options) {
-      return addRollupInput(options, [ENTRYPOINT_VIRTUAL_MODULE_ID]);
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro;
     },
     writeBundle(_, bundle) {
       for (const [chunkName, chunk] of Object.entries(bundle)) {
-        if (chunk.type !== "asset" && chunk.facadeModuleId === RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID) {
+        if (chunk.type !== "asset" && chunk.facadeModuleId === ACTIONS_RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID) {
           const outputDirectory = getServerOutputDirectory(opts.settings);
           internals.astroActionsEntryPoint = new URL(chunkName, outputDirectory);
         }
@@ -41,13 +39,10 @@ function vitePluginActions({
       if (id === VIRTUAL_MODULE_ID) {
         return RESOLVED_VIRTUAL_MODULE_ID;
       }
-      if (id === RUNTIME_VIRTUAL_MODULE_ID) {
-        return RESOLVED_RUNTIME_VIRTUAL_MODULE_ID;
-      }
       if (id === OPTIONS_VIRTUAL_MODULE_ID) {
         return RESOLVED_OPTIONS_VIRTUAL_MODULE_ID;
       }
-      if (id === ENTRYPOINT_VIRTUAL_MODULE_ID) {
+      if (id === ACTIONS_ENTRYPOINT_VIRTUAL_MODULE_ID) {
         const resolvedModule = await this.resolve(
           `${decodeURI(new URL("actions", settings.config.srcDir).pathname)}`
         );
@@ -55,7 +50,7 @@ function vitePluginActions({
           return RESOLVED_NOOP_ENTRYPOINT_VIRTUAL_MODULE_ID;
         }
         resolvedActionsId = resolvedModule.id;
-        return RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID;
+        return ACTIONS_RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID;
       }
     },
     async configureServer(server) {
@@ -69,21 +64,23 @@ function vitePluginActions({
       server.watcher.on("add", watcherCallback);
       server.watcher.on("change", watcherCallback);
     },
-    async load(id, opts) {
+    async load(id) {
       if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-        return { code: `export * from 'astro/actions/runtime/virtual.js';` };
+        if (this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client) {
+          return {
+            code: `export * from 'astro/actions/runtime/entrypoints/client.js';`
+          };
+        }
+        return {
+          code: `export * from 'astro/actions/runtime/entrypoints/server.js';`
+        };
       }
       if (id === RESOLVED_NOOP_ENTRYPOINT_VIRTUAL_MODULE_ID) {
         return { code: "export const server = {}" };
       }
-      if (id === RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID) {
+      if (id === ACTIONS_RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID) {
         return { code: `export { server } from ${JSON.stringify(resolvedActionsId)};` };
       }
-      if (id === RESOLVED_RUNTIME_VIRTUAL_MODULE_ID) {
-        return {
-          code: `export * from 'astro/actions/runtime/${opts?.ssr ? "server" : "client"}.js';`
-        };
-      }
       if (id === RESOLVED_OPTIONS_VIRTUAL_MODULE_ID) {
         return {
           code: `