astro 5.4.1 → 5.4.3

package/client.d.ts

@@ -193,14 +193,14 @@ declare module 'astro:config/server' {
 	// biome-ignore format: bug
 	type ServerConfigSerialized = import('./dist/types/public/manifest.js').ServerDeserializedManifest;
 	const manifest: ServerConfigSerialized;
-	export default manifest;
+	export = manifest;
 }
 
 declare module 'astro:config/client' {
 	// biome-ignore format: bug
 	type ClientConfigSerialized = import('./dist/types/public/manifest.js').ClientDeserializedManifest;
 	const manifest: ClientConfigSerialized;
-	export default manifest;
+	export = manifest;
 }
 
 declare module 'astro:components' {

package/components/Debug.astro

@@ -21,8 +21,9 @@ const value = Astro.props[key];
 		font-size: 14px;
 		padding: 1rem 1.5rem;
 		background: white;
-		font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell,
-			'Open Sans', 'Helvetica Neue', sans-serif;
+		font-family:
+			-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans',
+			'Helvetica Neue', sans-serif;
 	}
 
 	.astro-debug-header,

package/dist/actions/consts.d.ts

@@ -1,8 +1,8 @@
 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 ASTRO_ACTIONS_INTERNAL_MODULE_ID = "astro-internal:actions";
+export declare const RESOLVED_ASTRO_ACTIONS_INTERNAL_MODULE_ID: string;
 export declare const NOOP_ACTIONS = "\0noop-actions";
 export declare const ACTION_QUERY_PARAMS: {
     actionName: string;

package/dist/actions/consts.js

@@ -1,8 +1,8 @@
 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 ASTRO_ACTIONS_INTERNAL_MODULE_ID = "astro-internal:actions";
+const RESOLVED_ASTRO_ACTIONS_INTERNAL_MODULE_ID = "\0" + ASTRO_ACTIONS_INTERNAL_MODULE_ID;
 const NOOP_ACTIONS = "\0noop-actions";
 const ACTION_QUERY_PARAMS = {
   actionName: "_action",
@@ -13,9 +13,9 @@ export {
   ACTIONS_TYPES_FILE,
   ACTION_QUERY_PARAMS,
   ACTION_RPC_ROUTE_PATTERN,
+  ASTRO_ACTIONS_INTERNAL_MODULE_ID,
   NOOP_ACTIONS,
-  RESOLVED_VIRTUAL_INTERNAL_MODULE_ID,
+  RESOLVED_ASTRO_ACTIONS_INTERNAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
-  VIRTUAL_INTERNAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 };

package/dist/actions/integration.js

@@ -8,17 +8,13 @@ function astroIntegrationActionsRouteHandler({
   return {
     name: VIRTUAL_MODULE_ID,
     hooks: {
-      async "astro:config:setup"(params) {
+      async "astro:config:setup"() {
         settings.injectedRoutes.push({
           pattern: ACTION_RPC_ROUTE_PATTERN,
           entrypoint: "astro/actions/runtime/route.js",
           prerender: false,
           origin: "internal"
         });
-        params.addMiddleware({
-          entrypoint: "astro/actions/runtime/middleware.js",
-          order: "post"
-        });
       },
       "astro:config:done": async (params) => {
         if (params.buildOutput === "static") {

package/dist/actions/loadActions.d.ts

@@ -0,0 +1,8 @@
+import type { SSRActions } from '../core/app/types.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+/**
+ * It accepts a module loader and the astro settings, and it attempts to load the middlewares defined in the configuration.
+ *
+ * If not middlewares were not set, the function returns an empty array.
+ */
+export declare function loadActions(moduleLoader: ModuleLoader): Promise<SSRActions>;

package/dist/actions/loadActions.js

@@ -0,0 +1,13 @@
+import { ActionsCantBeLoaded } from "../core/errors/errors-data.js";
+import { AstroError } from "../core/errors/index.js";
+import { ASTRO_ACTIONS_INTERNAL_MODULE_ID } from "./consts.js";
+async function loadActions(moduleLoader) {
+  try {
+    return await moduleLoader.import(ASTRO_ACTIONS_INTERNAL_MODULE_ID);
+  } catch (error) {
+    throw new AstroError(ActionsCantBeLoaded, { cause: error });
+  }
+}
+export {
+  loadActions
+};

package/dist/actions/plugins.d.ts

@@ -1,5 +1,7 @@
 import type fsMod from 'node:fs';
 import type { Plugin as VitePlugin } from 'vite';
+import type { BuildInternals } from '../core/build/internal.js';
+import type { StaticBuildOptions } from '../core/build/types.js';
 import type { AstroSettings } from '../types/astro.js';
 /**
  * This plugin is responsible to load the known file `actions/index.js` / `actions.js`
@@ -9,6 +11,12 @@ import type { AstroSettings } from '../types/astro.js';
 export declare function vitePluginUserActions({ settings }: {
     settings: AstroSettings;
 }): VitePlugin;
+/**
+ * This plugin is used to retrieve the final entry point of the bundled actions.ts file
+ * @param opts
+ * @param internals
+ */
+export declare function vitePluginActionsBuild(opts: StaticBuildOptions, internals: BuildInternals): VitePlugin;
 export declare function vitePluginActions({ fs, settings, }: {
     fs: typeof fsMod;
     settings: AstroSettings;

package/dist/actions/plugins.js

@@ -1,9 +1,11 @@
+import { addRollupInput } from "../core/build/add-rollup-input.js";
 import { shouldAppendForwardSlash } from "../core/build/util.js";
+import { getOutputDirectory } from "../prerender/utils.js";
 import {
+  ASTRO_ACTIONS_INTERNAL_MODULE_ID,
   NOOP_ACTIONS,
-  RESOLVED_VIRTUAL_INTERNAL_MODULE_ID,
+  RESOLVED_ASTRO_ACTIONS_INTERNAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
-  VIRTUAL_INTERNAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 } from "./consts.js";
 import { isActionsFilePresent } from "./utils.js";
@@ -15,7 +17,7 @@ function vitePluginUserActions({ settings }) {
       if (id === NOOP_ACTIONS) {
         return NOOP_ACTIONS;
       }
-      if (id === VIRTUAL_INTERNAL_MODULE_ID) {
+      if (id === ASTRO_ACTIONS_INTERNAL_MODULE_ID) {
         const resolvedModule = await this.resolve(
           `${decodeURI(new URL("actions", settings.config.srcDir).pathname)}`
         );
@@ -23,18 +25,34 @@ function vitePluginUserActions({ settings }) {
           return NOOP_ACTIONS;
         }
         resolvedActionsId = resolvedModule.id;
-        return RESOLVED_VIRTUAL_INTERNAL_MODULE_ID;
+        return RESOLVED_ASTRO_ACTIONS_INTERNAL_MODULE_ID;
       }
     },
     load(id) {
       if (id === NOOP_ACTIONS) {
         return "export const server = {}";
-      } else if (id === RESOLVED_VIRTUAL_INTERNAL_MODULE_ID) {
+      } else if (id === RESOLVED_ASTRO_ACTIONS_INTERNAL_MODULE_ID) {
         return `export { server } from '${resolvedActionsId}';`;
       }
     }
   };
 }
+function vitePluginActionsBuild(opts, internals) {
+  return {
+    name: "@astro/plugin-actions-build",
+    options(options) {
+      return addRollupInput(options, [ASTRO_ACTIONS_INTERNAL_MODULE_ID]);
+    },
+    writeBundle(_, bundle) {
+      for (const [chunkName, chunk] of Object.entries(bundle)) {
+        if (chunk.type !== "asset" && chunk.facadeModuleId === RESOLVED_ASTRO_ACTIONS_INTERNAL_MODULE_ID) {
+          const outputDirectory = getOutputDirectory(opts.settings);
+          internals.astroActionsEntryPoint = new URL(chunkName, outputDirectory);
+        }
+      }
+    }
+  };
+}
 function vitePluginActions({
   fs,
   settings
@@ -83,5 +101,6 @@ export * from 'astro/actions/runtime/virtual/client.js';`;
 }
 export {
   vitePluginActions,
+  vitePluginActionsBuild,
   vitePluginUserActions
 };

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

@@ -19,7 +19,7 @@ export declare function defineAction<TOutput, TAccept extends ActionAccept | und
 }): 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 ActionMiddlewareContext = {
+export type AstroActionContext = {
     /** Information about an incoming action request. */
     action?: {
         /** Whether an action was called using an RPC function or by using an HTML form action. */
@@ -47,4 +47,4 @@ export type ActionMiddlewareContext = {
 /**
  * Access information about Action requests from middleware.
  */
-export declare function getActionContext(context: APIContext): ActionMiddlewareContext;
+export declare function getActionContext(context: APIContext): AstroActionContext;

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

@@ -11,7 +11,6 @@ import {
   hasContentType,
   isActionAPIContext
 } from "../utils.js";
-import { getAction } from "./get-action.js";
 import {
   ACTION_QUERY_PARAMS,
   ActionError,
@@ -151,7 +150,7 @@ function getActionContext(context) {
           pipeline.manifest.trailingSlash,
           pipeline.manifest.buildFormat
         ) ? removeTrailingForwardSlash(callerInfo.name) : callerInfo.name;
-        const baseAction = await getAction(callerInfoName);
+        const baseAction = await pipeline.getAction(callerInfoName);
         let input;
         try {
           input = await parseRequestBody(context.request);

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

@@ -1,4 +1,5 @@
 import type { z } from 'zod';
+import { AstroError } from '../../../core/errors/errors.js';
 import { appendForwardSlash as _appendForwardSlash } from '../../../core/path.js';
 import type { ErrorInferenceObject, MaybePromise, ActionAPIContext as _ActionAPIContext } from '../utils.js';
 export type ActionAPIContext = _ActionAPIContext;
@@ -56,3 +57,4 @@ export type SerializedActionResult = {
 };
 export declare function serializeActionResult(res: SafeResult<any, any>): SerializedActionResult;
 export declare function deserializeActionResult(res: SerializedActionResult): SafeResult<any, any>;
+export declare function astroCalledServerError(): AstroError;

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

@@ -1,6 +1,9 @@
 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 {
+  ActionCalledFromServerError,
+  ActionsReturnedInvalidDataError
+} from "../../../core/errors/errors-data.js";
 import { AstroError } from "../../../core/errors/errors.js";
 import { appendForwardSlash as _appendForwardSlash } from "../../../core/path.js";
 import { ACTION_QUERY_PARAMS as _ACTION_QUERY_PARAMS } from "../../consts.js";
@@ -224,12 +227,16 @@ const actionResultErrorStack = /* @__PURE__ */ function actionResultErrorStackFn
     }
   };
 }();
+function astroCalledServerError() {
+  return new AstroError(ActionCalledFromServerError);
+}
 export {
   ACTION_ERROR_CODES,
   ACTION_QUERY_PARAMS,
   ActionError,
   ActionInputError,
   appendForwardSlash,
+  astroCalledServerError,
   callSafely,
   deserializeActionResult,
   getActionQueryString,

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

@@ -1,4 +1,22 @@
 import type { ImageMetadata, UnresolvedImageTransform } from '../types.js';
+/**
+ * Determines if the given source is an ECMAScript Module (ESM) imported image.
+ *
+ * @param {ImageMetadata | string} src - The source to check. It can be an `ImageMetadata` object or a string.
+ * @return {boolean} Returns `true` if the source is an `ImageMetadata` object, otherwise `false`.
+ */
 export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
+/**
+ * Determines if the provided source is a remote image URL in the form of a string.
+ *
+ * @param {ImageMetadata | string} src - The source to check, which can either be an `ImageMetadata` object or a string.
+ * @return {boolean} Returns `true` if the source is a string, otherwise `false`.
+ */
 export declare function isRemoteImage(src: ImageMetadata | string): src is string;
+/**
+ * Resolves the source of an image transformation by handling asynchronous or synchronous inputs.
+ *
+ * @param {UnresolvedImageTransform['src']} src - The source of the image transformation.
+ * @return {Promise<string | ImageMetadata>} A promise that resolves to the image source. It returns either the default export of the resolved source or the resolved source itself if the default export doesn't exist.
+ */
 export declare function resolveSrc(src: UnresolvedImageTransform['src']): Promise<string | ImageMetadata>;

package/dist/assets/utils/imageKind.js

@@ -5,7 +5,11 @@ function isRemoteImage(src) {
   return typeof src === "string";
 }
 async function resolveSrc(src) {
-  return typeof src === "object" && "then" in src ? (await src).default ?? await src : src;
+  if (typeof src === "object" && "then" in src) {
+    const resource = await src;
+    return resource.default ?? resource;
+  }
+  return src;
 }
 export {
   isESMImportedImage,

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

@@ -1,8 +1,13 @@
+/**
+ * NOTE: this is a public module exposed to the user, so all functions exposed
+ * here must be documented via JsDoc and in the docs website.
+ *
+ * If some functions don't need to be exposed, just import the file that contains the functions.
+ */
 export { emitESMImage } from './node/emitAsset.js';
 export { isESMImportedImage, isRemoteImage } from './imageKind.js';
 export { imageMetadata } from './metadata.js';
 export { getOrigQueryParams } from './queryParams.js';
 export { hashTransform, propsToFilename } from './transformToPath.js';
 export { inferRemoteSize } from './remoteProbe.js';
-export { makeSvgComponent } from './svg.js';
 export { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern, } from './remotePattern.js';

package/dist/assets/utils/index.js

@@ -4,7 +4,6 @@ import { imageMetadata } from "./metadata.js";
 import { getOrigQueryParams } from "./queryParams.js";
 import { hashTransform, propsToFilename } from "./transformToPath.js";
 import { inferRemoteSize } from "./remoteProbe.js";
-import { makeSvgComponent } from "./svg.js";
 import {
   isRemoteAllowed,
   matchHostname,
@@ -22,7 +21,6 @@ export {
   isESMImportedImage,
   isRemoteAllowed,
   isRemoteImage,
-  makeSvgComponent,
   matchHostname,
   matchPathname,
   matchPattern,

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

@@ -1,2 +1,10 @@
 import type { ImageMetadata } from '../types.js';
+/**
+ * Extracts image metadata such as dimensions, format, and orientation from the provided image data.
+ *
+ * @param {Uint8Array} data - The binary data of the image.
+ * @param {string} [src] - The source path or URL of the image, used for error messages. Optional.
+ * @return {Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>} A promise that resolves with the extracted metadata, excluding `src` and `fsPath`.
+ * @throws {AstroError} Throws an error if the image metadata cannot be extracted.
+ */
 export declare function imageMetadata(data: Uint8Array, src?: string): Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;

package/dist/assets/utils/metadata.js

@@ -1,28 +1,29 @@
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 import { lookup as probe } from "../utils/vendor/image-size/lookup.js";
 async function imageMetadata(data, src) {
+  let result;
   try {
-    const result = probe(data);
-    if (!result.height || !result.width || !result.type) {
-      throw new AstroError({
-        ...AstroErrorData.NoImageMetadata,
-        message: AstroErrorData.NoImageMetadata.message(src)
-      });
-    }
-    const { width, height, type, orientation } = result;
-    const isPortrait = (orientation || 0) >= 5;
-    return {
-      width: isPortrait ? height : width,
-      height: isPortrait ? width : height,
-      format: type,
-      orientation
-    };
+    result = probe(data);
   } catch {
     throw new AstroError({
       ...AstroErrorData.NoImageMetadata,
       message: AstroErrorData.NoImageMetadata.message(src)
     });
   }
+  if (!result.height || !result.width || !result.type) {
+    throw new AstroError({
+      ...AstroErrorData.NoImageMetadata,
+      message: AstroErrorData.NoImageMetadata.message(src)
+    });
+  }
+  const { width, height, type, orientation } = result;
+  const isPortrait = (orientation || 0) >= 5;
+  return {
+    width: isPortrait ? height : width,
+    height: isPortrait ? width : height,
+    format: type,
+    orientation
+  };
 }
 export {
   imageMetadata

package/dist/assets/utils/node/emitAsset.d.ts

@@ -4,6 +4,15 @@ type FileEmitter = vite.Rollup.EmitFile;
 type ImageMetadataWithContents = ImageMetadata & {
     contents?: Buffer;
 };
+/**
+ * Processes an image file and emits its metadata and optionally its contents. This function supports both build and development modes.
+ *
+ * @param {string | undefined} id - The identifier or path of the image file to process. If undefined, the function returns immediately.
+ * @param {boolean} _watchMode - **Deprecated**: Indicates if the method is operating in watch mode. This parameter will be removed or updated in the future.
+ * @param {boolean} experimentalSvgEnabled - A flag to enable experimental handling of SVG files. Embeds SVG file data if set to true.
+ * @param {FileEmitter | undefined} [fileEmitter] - Function for emitting files during the build process. May throw in certain scenarios.
+ * @return {Promise<ImageMetadataWithContents | undefined>} Resolves to metadata with optional image contents or `undefined` if processing fails.
+ */
 export declare function emitESMImage(id: string | undefined, 
 /** @deprecated */
 _watchMode: boolean, experimentalSvgEnabled: boolean, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;

package/dist/assets/utils/node/emitAsset.js

@@ -24,7 +24,7 @@ async function emitESMImage(id, _watchMode, experimentalSvgEnabled, fileEmitter)
     writable: false,
     value: id
   });
-  if (fileMetadata.format === "svg" && experimentalSvgEnabled === true) {
+  if (fileMetadata.format === "svg" && experimentalSvgEnabled) {
     emittedImage.contents = fileData;
   }
   let isBuild = typeof fileEmitter === "function";

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

@@ -1,2 +1,11 @@
 import type { ImageMetadata } from '../types.js';
+/**
+ * Extracts the original image query parameters (width, height, format) from the given `URLSearchParams` object
+ * and returns them as an object. If any of the required parameters are missing or invalid, the function returns undefined.
+ *
+ * The `width` and `height` are parsed to integer values.
+ *
+ * @param {URLSearchParams} params - The `URLSearchParams` object containing the query parameters.
+ * @return {Pick<ImageMetadata, 'width' | 'height' | 'format'> | undefined} An object with the original image parameters (width, height, format) or undefined if any parameter is missing.
+ */
 export declare function getOrigQueryParams(params: URLSearchParams): Pick<ImageMetadata, 'width' | 'height' | 'format'> | undefined;

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

@@ -1,2 +1,9 @@
 import type { ImageMetadata } from '../types.js';
+/**
+ * Infers the dimensions of a remote image by streaming its data and analyzing it progressively until sufficient metadata is available.
+ *
+ * @param {string} url - The URL of the remote image from which to infer size metadata.
+ * @return {Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>} Returns a promise that resolves to an object containing the image dimensions metadata excluding `src` and `fsPath`.
+ * @throws {AstroError} Thrown when the fetching fails or metadata cannot be extracted.
+ */
 export declare function inferRemoteSize(url: string): Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;

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

@@ -1,3 +1,33 @@
 import type { ImageTransform } from '../types.js';
+/**
+ * Converts a file path and transformation properties of the transformation image service, into a formatted filename.
+ *
+ * The formatted filename follows this structure:
+ *
+ * `<prefixDirname>/<baseFilename>_<hash><outputExtension>`
+ *
+ * - `prefixDirname`: If the image is an ESM imported image, this is the directory name of the original file path; otherwise, it will be an empty string.
+ * - `baseFilename`: The base name of the file or a hashed short name if the file is a `data:` URI.
+ * - `hash`: A unique hash string generated to distinguish the transformed file.
+ * - `outputExtension`: The desired output file extension derived from the `transform.format` or the original file extension.
+ *
+ * ## Example
+ * - Input: `filePath = '/images/photo.jpg'`, `transform = { format: 'png', src: '/images/photo.jpg' }`, `hash = 'abcd1234'`.
+ * - Output: `/images/photo_abcd1234.png`
+ *
+ * @param {string} filePath - The original file path or data URI of the source image.
+ * @param {ImageTransform} transform - An object representing the transformation properties, including format and source.
+ * @param {string} hash - A unique hash used to differentiate the transformed file.
+ * @return {string} The generated filename based on the provided input, transformations, and hash.
+ */
 export declare function propsToFilename(filePath: string, transform: ImageTransform, hash: string): string;
+/**
+ * Transforms the provided `transform` object into a hash string based on selected properties
+ * and the specified `imageService`.
+ *
+ * @param {ImageTransform} transform - The transform object containing various image transformation properties.
+ * @param {string} imageService - The name of the image service related to the transform.
+ * @param {string[]} propertiesToHash - An array of property names from the `transform` object that should be used to generate the hash.
+ * @return {string} A hashed string created from the specified properties of the `transform` object and the image service.
+ */
 export declare function hashTransform(transform: ImageTransform, imageService: string, propertiesToHash: string[]): string;

package/dist/cli/add/index.js

@@ -6,7 +6,7 @@ import { diffWords } from "diff";
 import { bold, cyan, dim, green, magenta, red, yellow } from "kleur/colors";
 import { builders, generateCode, loadFile } from "magicast";
 import { getDefaultExportOptions } from "magicast/helpers";
-import preferredPM from "preferred-pm";
+import { detect, resolveCommand } from "package-manager-detector";
 import prompts from "prompts";
 import maxSatisfying from "semver/ranges/max-satisfying.js";
 import yoctoSpinner from "yocto-spinner";
@@ -190,7 +190,7 @@ async function add(names, { flags }) {
           logger.debug("add", `Using existing db configuration`);
         }
       }
-      if (integrations.find((integration) => integration.id === "lit") && (await preferredPM(fileURLToPath(root)))?.name === "pnpm") {
+      if (integrations.find((integration) => integration.id === "lit") && (await detect({ cwd: fileURLToPath(root) }))?.name === "pnpm") {
         await setupIntegrationConfig({
           root,
           logger,
@@ -494,28 +494,6 @@ ${message}`
     return 2 /* cancelled */;
   }
 }
-async function getInstallIntegrationsCommand({
-  integrations,
-  logger,
-  cwd = process.cwd()
-}) {
-  const pm = await preferredPM(cwd);
-  logger.debug("add", `package manager: ${JSON.stringify(pm)}`);
-  if (!pm) return null;
-  const dependencies = await convertIntegrationsToInstallSpecifiers(integrations);
-  switch (pm.name) {
-    case "npm":
-      return { pm: "npm", command: "install", flags: [], dependencies };
-    case "yarn":
-      return { pm: "yarn", command: "add", flags: [], dependencies };
-    case "pnpm":
-      return { pm: "pnpm", command: "add", flags: [], dependencies };
-    case "bun":
-      return { pm: "bun", command: "add", flags: [], dependencies };
-    default:
-      return null;
-  }
-}
 async function convertIntegrationsToInstallSpecifiers(integrations) {
   const ranges = {};
   for (let { dependencies } of integrations) {
@@ -550,7 +528,14 @@ async function tryToInstallIntegrations({
   flags,
   logger
 }) {
-  const installCommand = await getInstallIntegrationsCommand({ integrations, cwd, logger });
+  const packageManager = await detect({
+    cwd,
+    // Include the `install-metadata` strategy to have the package manager that's
+    // used for installation take precedence
+    strategies: ["install-metadata", "lockfile", "packageManager-field"]
+  });
+  logger.debug("add", `package manager: "${packageManager?.name}"`);
+  if (!packageManager) return 0 /* none */;
   const inheritedFlags = Object.entries(flags).map(([flag]) => {
     if (flag == "_") return;
     if (INHERITED_FLAGS.has(flag)) {
@@ -558,60 +543,46 @@ async function tryToInstallIntegrations({
       return `--${flag}`;
     }
   }).filter(Boolean).flat();
-  if (installCommand === null) {
-    return 0 /* none */;
-  } else {
-    const coloredOutput = `${bold(installCommand.pm)} ${installCommand.command}${[
-      "",
-      ...installCommand.flags,
-      ...inheritedFlags
-    ].join(" ")} ${cyan(installCommand.dependencies.join(" "))}`;
-    const message = `
+  const installCommand = resolveCommand(packageManager?.agent ?? "npm", "add", inheritedFlags);
+  if (!installCommand) return 0 /* none */;
+  const installSpecifiers = await convertIntegrationsToInstallSpecifiers(integrations);
+  const coloredOutput = `${bold(installCommand.command)} ${installCommand.args.join(" ")} ${cyan(installSpecifiers.join(" "))}`;
+  const message = `
 ${boxen(coloredOutput, {
-      margin: 0.5,
-      padding: 0.5,
-      borderStyle: "round"
-    })}
+    margin: 0.5,
+    padding: 0.5,
+    borderStyle: "round"
+  })}
 `;
-    logger.info(
-      "SKIP_FORMAT",
-      `
+  logger.info(
+    "SKIP_FORMAT",
+    `
   ${magenta("Astro will run the following command:")}
   ${dim(
-        "If you skip this step, you can always run it yourself later"
-      )}
+      "If you skip this step, you can always run it yourself later"
+    )}
 ${message}`
-    );
-    if (await askToContinue({ flags })) {
-      const spinner = yoctoSpinner({ text: "Installing dependencies..." }).start();
-      try {
-        await exec(
-          installCommand.pm,
-          [
-            installCommand.command,
-            ...installCommand.flags,
-            ...inheritedFlags,
-            ...installCommand.dependencies
-          ],
-          {
-            nodeOptions: {
-              cwd,
-              // reset NODE_ENV to ensure install command run in dev mode
-              env: { NODE_ENV: void 0 }
-            }
-          }
-        );
-        spinner.success();
-        return 1 /* updated */;
-      } catch (err) {
-        spinner.error();
-        logger.debug("add", "Error installing dependencies", err);
-        console.error("\n", err.stdout || err.message, "\n");
-        return 3 /* failure */;
-      }
-    } else {
-      return 2 /* cancelled */;
+  );
+  if (await askToContinue({ flags })) {
+    const spinner = yoctoSpinner({ text: "Installing dependencies..." }).start();
+    try {
+      await exec(installCommand.command, [...installCommand.args, ...installSpecifiers], {
+        nodeOptions: {
+          cwd,
+          // reset NODE_ENV to ensure install command run in dev mode
+          env: { NODE_ENV: void 0 }
+        }
+      });
+      spinner.success();
+      return 1 /* updated */;
+    } catch (err) {
+      spinner.error();
+      logger.debug("add", "Error installing dependencies", err);
+      console.error("\n", err.stdout || err.message, "\n");
+      return 3 /* failure */;
     }
+  } else {
+    return 2 /* cancelled */;
   }
 }
 async function validateIntegrations(integrations) {