astro 5.0.0-alpha.1 → 5.0.0-alpha.2

package/client.d.ts

@@ -145,6 +145,9 @@ declare module 'astro:transitions/client' {
 		import('./dist/virtual-modules/transitions-events.js').TransitionBeforeSwapEvent;
 	export const isTransitionBeforePreparationEvent: EventModule['isTransitionBeforePreparationEvent'];
 	export const isTransitionBeforeSwapEvent: EventModule['isTransitionBeforeSwapEvent'];
+	type TransitionSwapFunctionModule =
+		typeof import('./dist/virtual-modules/transitions-swap-functions.js');
+	export const swapFunctions: TransitionSwapFunctionModule['swapFunctions'];
 }
 
 declare module 'astro:prefetch' {
@@ -167,7 +170,12 @@ declare module 'astro:components' {
 	export * from 'astro/components';
 }
 
+declare module 'astro:schema' {
+	export * from 'astro/zod';
+}
+
 type MD = import('./dist/types/public/content.js').MarkdownInstance<Record<string, any>>;
+
 interface ExportedMarkdownModuleEntities {
 	frontmatter: MD['frontmatter'];
 	file: MD['file'];

package/dist/actions/integration.d.ts

@@ -0,0 +1,9 @@
+import type { AstroSettings } from '../types/astro.js';
+import type { AstroIntegration } from '../types/public/integrations.js';
+/**
+ * This integration is applied when the user is using Actions in their project.
+ * It will inject the necessary routes and middlewares to handle actions.
+ */
+export default function astroIntegrationActionsRouteHandler({ settings, }: {
+    settings: AstroSettings;
+}): AstroIntegration;

package/dist/actions/integration.js

@@ -0,0 +1,45 @@
+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, VIRTUAL_MODULE_ID } from "./consts.js";
+function astroIntegrationActionsRouteHandler({
+  settings
+}) {
+  return {
+    name: VIRTUAL_MODULE_ID,
+    hooks: {
+      async "astro:config:setup"(params) {
+        params.injectRoute({
+          pattern: "/_actions/[...path]",
+          entrypoint: "astro/actions/runtime/route.js",
+          prerender: false
+        });
+        params.addMiddleware({
+          entrypoint: "astro/actions/runtime/middleware.js",
+          order: "post"
+        });
+      },
+      "astro:config:done": async (params) => {
+        if (!isServerLikeOutput(params.config)) {
+          const error = new AstroError(ActionsWithoutServerOutputError);
+          error.stack = void 0;
+          throw error;
+        }
+        const stringifiedActionsImport = JSON.stringify(
+          viteID(new URL("./actions", params.config.srcDir))
+        );
+        settings.injectedTypes.push({
+          filename: ACTIONS_TYPES_FILE,
+          content: `declare module "astro:actions" {
+	type Actions = typeof import(${stringifiedActionsImport})["server"];
+
+	export const actions: Actions;
+}`
+        });
+      }
+    }
+  };
+}
+export {
+  astroIntegrationActionsRouteHandler as default
+};

package/dist/actions/{index.d.ts → plugins.d.ts}

@@ -1,11 +1,6 @@
-import fsMod from 'node:fs';
+import type fsMod from 'node:fs';
 import type { Plugin as VitePlugin } from 'vite';
 import type { AstroSettings } from '../types/astro.js';
-import type { AstroIntegration } from '../types/public/integrations.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.
@@ -14,3 +9,7 @@ export default function astroActions({ fs, settings, }: {
 export declare function vitePluginUserActions({ settings }: {
     settings: AstroSettings;
 }): VitePlugin;
+export declare function vitePluginActions({ fs, settings, }: {
+    fs: typeof fsMod;
+    settings: AstroSettings;
+}): VitePlugin;

package/dist/actions/plugins.js

@@ -0,0 +1,80 @@
+import {
+  NOOP_ACTIONS,
+  RESOLVED_VIRTUAL_INTERNAL_MODULE_ID,
+  RESOLVED_VIRTUAL_MODULE_ID,
+  VIRTUAL_INTERNAL_MODULE_ID,
+  VIRTUAL_MODULE_ID
+} from "./consts.js";
+import { isActionsFilePresent } from "./utils.js";
+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}';`;
+      }
+    }
+  };
+}
+function vitePluginActions({
+  fs,
+  settings
+}) {
+  return {
+    name: VIRTUAL_MODULE_ID,
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+    },
+    async configureServer(server) {
+      const filePresentOnStartup = await isActionsFilePresent(fs, settings.config.srcDir);
+      async function watcherCallback() {
+        const filePresent = await isActionsFilePresent(fs, settings.config.srcDir);
+        if (filePresentOnStartup !== filePresent) {
+          server.restart();
+        }
+      }
+      server.watcher.on("add", watcherCallback);
+      server.watcher.on("change", watcherCallback);
+    },
+    async load(id, opts) {
+      if (id !== RESOLVED_VIRTUAL_MODULE_ID) return;
+      let code = await fs.promises.readFile(
+        new URL("../../templates/actions.mjs", import.meta.url),
+        "utf-8"
+      );
+      if (opts?.ssr) {
+        code += `
+export * from 'astro/actions/runtime/virtual/server.js';`;
+      } else {
+        code += `
+export * from 'astro/actions/runtime/virtual/client.js';`;
+      }
+      return code;
+    }
+  };
+}
+export {
+  vitePluginActions,
+  vitePluginUserActions
+};

package/dist/actions/runtime/middleware.js

@@ -1,6 +1,4 @@
 import { yellow } from "kleur/colors";
-import { ActionQueryStringInvalidError } from "../../core/errors/errors-data.js";
-import { AstroError } from "../../core/errors/errors.js";
 import { defineMiddleware } from "../../core/middleware/index.js";
 import { ACTION_QUERY_PARAMS } from "../consts.js";
 import { formContentTypes, hasContentType } from "./utils.js";
@@ -9,8 +7,16 @@ import {
   serializeActionResult
 } from "./virtual/shared.js";
 const onRequest = defineMiddleware(async (context, next) => {
+  if (context._isPrerendered) {
+    if (context.request.method === "POST") {
+      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 locals = context.locals;
-  const { request } = context;
   if (locals._actionPayload) return next();
   const actionPayload = context.cookies.get(ACTION_QUERY_PARAMS.actionPayload)?.json();
   if (actionPayload) {
@@ -19,20 +25,10 @@ const onRequest = defineMiddleware(async (context, next) => {
     }
     return renderResult({ context, next, ...actionPayload });
   }
-  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(ACTION_QUERY_PARAMS.actionName);
   if (context.request.method === "POST" && actionName) {
     return handlePost({ context, next, actionName });
   }
-  if (context.request.method === "POST") {
-    return handlePostLegacy({ context, next });
-  }
   return next();
 });
 async function renderResult({
@@ -61,12 +57,6 @@ async function handlePost({
 }) {
   const { request } = context;
   const baseAction = await getAction(actionName);
-  if (!baseAction) {
-    throw new AstroError({
-      ...ActionQueryStringInvalidError,
-      message: ActionQueryStringInvalidError.message(actionName)
-    });
-  }
   const contentType = request.headers.get("content-type");
   let formData;
   if (contentType && hasContentType(contentType, formContentTypes)) {
@@ -102,28 +92,6 @@ async function redirectWithResult({
   }
   return context.redirect(context.url.pathname);
 }
-async function handlePostLegacy({ context, next }) {
-  const { request } = 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 next();
-  const actionName = formData.get(ACTION_QUERY_PARAMS.actionName);
-  if (!actionName) return next();
-  const baseAction = await getAction(actionName);
-  if (!baseAction) {
-    throw new AstroError({
-      ...ActionQueryStringInvalidError,
-      message: ActionQueryStringInvalidError.message(actionName)
-    });
-  }
-  const action = baseAction.bind(context);
-  const actionResult = await action(formData);
-  return redirectWithResult({ context, actionName, actionResult });
-}
 function isActionPayload(json) {
   if (typeof json !== "object" || json == null) return false;
   if (!("actionResult" in json) || typeof json.actionResult !== "object") return false;

package/dist/actions/runtime/route.js

@@ -3,9 +3,13 @@ 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);
-  if (!baseAction) {
-    return new Response(null, { status: 404 });
+  let baseAction;
+  try {
+    baseAction = await getAction(url.pathname);
+  } catch (e) {
+    if (import.meta.env.DEV) throw e;
+    console.error(e);
+    return new Response(e instanceof Error ? e.message : null, { status: 404 });
   }
   const contentType = request.headers.get("Content-Type");
   const contentLength = request.headers.get("Content-Length");

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

@@ -1,7 +1,7 @@
 import type { APIContext } from '../../types/public/context.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 ActionAPIContext = Omit<APIContext, 'getActionResult' | 'callAction' | 'props' | 'redirect'>;
 export type MaybePromise<T> = T | Promise<T>;
 /**
  * Used to preserve the input schema type in the error object.

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

@@ -1,3 +1,2 @@
 export * from './shared.js';
 export declare function defineAction(): void;
-export declare const z: {};

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

@@ -2,15 +2,6 @@ export * from "./shared.js";
 function defineAction() {
   throw new Error("[astro:action] `defineAction()` unexpectedly used on the client.");
 }
-const z = new Proxy(
-  {},
-  {
-    get() {
-      throw new Error("[astro:action] `z` unexpectedly used on the client.");
-    }
-  }
-);
 export {
-  defineAction,
-  z
+  defineAction
 };

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

@@ -5,4 +5,4 @@ import type { ActionAccept, ActionClient } from './server.js';
  * 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>;
+export declare function getAction(path: string): Promise<ActionClient<unknown, ActionAccept, ZodType>>;

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

@@ -1,14 +1,26 @@
+import { ActionNotFoundError } from "../../../core/errors/errors-data.js";
+import { AstroError } from "../../../core/errors/errors.js";
 async function getAction(path) {
   const pathKeys = path.replace("/_actions/", "").split(".");
   let { server: actionLookup } = await import("astro:internal-actions");
+  if (actionLookup == null || !(typeof actionLookup === "object")) {
+    throw new TypeError(
+      `Expected \`server\` export in actions file to be an object. Received ${typeof actionLookup}.`
+    );
+  }
   for (const key of pathKeys) {
     if (!(key in actionLookup)) {
-      return void 0;
+      throw new AstroError({
+        ...ActionNotFoundError,
+        message: ActionNotFoundError.message(pathKeys.join("."))
+      });
     }
     actionLookup = actionLookup[key];
   }
   if (typeof actionLookup !== "function") {
-    return void 0;
+    throw new TypeError(
+      `Expected handler for action ${pathKeys.join(".")} to be a function. Received ${typeof actionLookup}.`
+    );
   }
   return actionLookup;
 }

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

@@ -2,18 +2,16 @@ import { z } from 'zod';
 import type { ActionAPIContext, ErrorInferenceObject, MaybePromise } from '../utils.js';
 import { type SafeResult } from './shared.js';
 export * from './shared.js';
-export { z } from 'zod';
 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<SafeResult<z.input<TInputSchema> extends ErrorInferenceObject ? z.input<TInputSchema> : ErrorInferenceObject, Awaited<TOutput>>>) & {
+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>>;
 } : ((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, }: {
+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>;

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

@@ -3,7 +3,6 @@ import { ActionCalledFromServerError } from "../../../core/errors/errors-data.js
 import { AstroError } from "../../../core/errors/errors.js";
 import { ActionError, ActionInputError, callSafely } from "./shared.js";
 export * from "./shared.js";
-import { z as z2 } from "zod";
 function defineAction({
   accept,
   input: inputSchema,
@@ -34,8 +33,11 @@ function getFormServerHandler(handler, inputSchema) {
         message: "This action only accepts FormData."
       });
     }
-    if (!(inputSchema instanceof z.ZodObject)) return await handler(unparsedInput, context);
-    const parsed = await inputSchema.safeParseAsync(formDataToObject(unparsedInput, inputSchema));
+    if (!inputSchema) return await handler(unparsedInput, context);
+    const baseSchema = unwrapSchemaEffects(inputSchema);
+    const parsed = await inputSchema.safeParseAsync(
+      baseSchema instanceof z.ZodObject ? formDataToObject(unparsedInput, baseSchema) : unparsedInput
+    );
     if (!parsed.success) {
       throw new ActionInputError(parsed.error.issues);
     }
@@ -59,7 +61,7 @@ function getJsonServerHandler(handler, inputSchema) {
   };
 }
 function formDataToObject(formData, schema) {
-  const obj = {};
+  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) {
@@ -98,8 +100,18 @@ function handleFormDataGet(key, formData, validator, baseValidator) {
   }
   return validator instanceof z.ZodNumber ? Number(value) : value;
 }
+function unwrapSchemaEffects(schema) {
+  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;
+    }
+  }
+  return schema;
+}
 export {
   defineAction,
-  formDataToObject,
-  z2 as z
+  formDataToObject
 };

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

@@ -1,5 +1,6 @@
 import type { z } from 'zod';
-import type { ErrorInferenceObject, MaybePromise } from '../utils.js';
+import type { ErrorInferenceObject, MaybePromise, ActionAPIContext as _ActionAPIContext } from '../utils.js';
+export type ActionAPIContext = _ActionAPIContext;
 export declare const ACTION_QUERY_PARAMS: {
     actionName: string;
     actionPayload: string;
@@ -38,17 +39,6 @@ export declare class ActionInputError<T extends ErrorInferenceObject> extends Ac
 }
 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";
-    readonly value: string;
-};
 export type SerializedActionResult = {
     type: 'data';
     contentType: 'application/json+devalue';

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

@@ -1,4 +1,7 @@
 import { parse as devalueParse, stringify as devalueStringify } from "devalue";
+import { REDIRECT_STATUS_CODES } from "../../../core/constants.js";
+import { ActionsReturnedInvalidDataError } from "../../../core/errors/errors-data.js";
+import { AstroError } from "../../../core/errors/errors.js";
 import { ACTION_QUERY_PARAMS as _ACTION_QUERY_PARAMS } from "../../consts.js";
 const ACTION_QUERY_PARAMS = _ACTION_QUERY_PARAMS;
 const ACTION_ERROR_CODES = [
@@ -118,18 +121,6 @@ function getActionQueryString(name) {
   const searchParams = new URLSearchParams({ [_ACTION_QUERY_PARAMS.actionName]: 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: actionName
-  };
-}
 function serializeActionResult(res) {
   if (res.error) {
     if (import.meta.env?.DEV) {
@@ -151,22 +142,48 @@ function serializeActionResult(res) {
       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: devalueStringify(res.data, {
-      // Add support for URL objects
-      URL: (value) => value instanceof URL && value.href
-    })
+    body
   };
 }
 function deserializeActionResult(res) {
   if (res.type === "error") {
+    let json;
+    try {
+      json = JSON.parse(res.body);
+    } catch {
+      return {
+        data: void 0,
+        error: new ActionError({
+          message: res.body,
+          code: "INTERNAL_SERVER_ERROR"
+        })
+      };
+    }
     if (import.meta.env?.PROD) {
-      return { error: ActionError.fromJson(JSON.parse(res.body)), data: void 0 };
+      return { error: ActionError.fromJson(json), data: void 0 };
     } else {
-      const error = ActionError.fromJson(JSON.parse(res.body));
+      const error = ActionError.fromJson(json);
       error.stack = actionResultErrorStack.get();
       return {
         error,
@@ -202,7 +219,6 @@ export {
   ActionInputError,
   callSafely,
   deserializeActionResult,
-  getActionProps,
   getActionQueryString,
   isActionError,
   isInputError,

package/dist/actions/utils.d.ts

@@ -1,6 +1,11 @@
+import type fsMod from 'node:fs';
 import type { APIContext } from '../types/public/context.js';
 import type { Locals } from './runtime/middleware.js';
 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(context: ActionAPIContext): APIContext['callAction'];
+/**
+ * Check whether the Actions config file is present.
+ */
+export declare function isActionsFilePresent(fs: typeof fsMod, srcDir: URL): Promise<boolean>;

package/dist/actions/utils.js

@@ -1,3 +1,4 @@
+import * as eslexer from "es-module-lexer";
 import { deserializeActionResult, getActionQueryString } from "./runtime/virtual/shared.js";
 function hasActionPayload(locals) {
   return "_actionPayload" in locals;
@@ -16,8 +17,46 @@ function createCallAction(context) {
     return action(input);
   };
 }
+let didInitLexer = false;
+async function isActionsFilePresent(fs, srcDir) {
+  if (!didInitLexer) await eslexer.init;
+  const actionsFile = search(fs, srcDir);
+  if (!actionsFile) return false;
+  let contents;
+  try {
+    contents = fs.readFileSync(actionsFile, "utf-8");
+  } catch {
+    return false;
+  }
+  const [, exports] = eslexer.parse(contents, actionsFile.pathname);
+  for (const exp of exports) {
+    if (exp.n === "server") {
+      return true;
+    }
+  }
+  return false;
+}
+function search(fs, srcDir) {
+  const paths = [
+    "actions.mjs",
+    "actions.js",
+    "actions.mts",
+    "actions.ts",
+    "actions/index.mjs",
+    "actions/index.js",
+    "actions/index.mts",
+    "actions/index.ts"
+  ].map((p) => new URL(p, srcDir));
+  for (const file of paths) {
+    if (fs.existsSync(file)) {
+      return file;
+    }
+  }
+  return void 0;
+}
 export {
   createCallAction,
   createGetActionResult,
-  hasActionPayload
+  hasActionPayload,
+  isActionsFilePresent
 };

package/dist/assets/utils/resolveImports.d.ts

@@ -5,5 +5,5 @@
  * @param filePath The path to the file that contains the imagem relative to the site root
  * @returns A module id of the image that can be rsolved by Vite, or undefined if it is not a local image
  */
-export declare function imageSrcToImportId(imageSrc: string, filePath: string): string | undefined;
+export declare function imageSrcToImportId(imageSrc: string, filePath?: string): string | undefined;
 export declare const importIdToSymbolName: (importId: string) => string;

package/dist/assets/utils/resolveImports.js

@@ -12,7 +12,9 @@ function imageSrcToImportId(imageSrc, filePath) {
     return;
   }
   const params = new URLSearchParams(CONTENT_IMAGE_FLAG);
-  params.set("importer", filePath);
+  if (filePath) {
+    params.set("importer", filePath);
+  }
   return `${imageSrc}?${params.toString()}`;
 }
 const importIdToSymbolName = (importId) => `__ASTRO_IMAGE_IMPORT_${shorthash(importId)}`;

package/dist/cli/add/index.d.ts

@@ -1,6 +1,14 @@
+import { type ProxifiedModule } from 'magicast';
 import { type Flags } from '../flags.js';
 interface AddOptions {
     flags: Flags;
 }
+interface IntegrationInfo {
+    id: string;
+    packageName: string;
+    dependencies: [name: string, version: string][];
+    type: 'integration' | 'adapter';
+}
 export declare function add(names: string[], { flags }: AddOptions): Promise<void>;
+export declare function setAdapter(mod: ProxifiedModule<any>, adapter: IntegrationInfo): void;
 export {};