hardhat 3.1.8 → 3.1.10

package/src/internal/cli/error-handler.ts

@@ -5,6 +5,7 @@ import {
 import chalk from "chalk";
 
 import { HARDHAT_NAME, HARDHAT_WEBSITE_URL } from "../constants.js";
+import { UsingHardhat2PluginError } from "../using-hardhat2-plugin-errors.js";
 
 /**
  * The different categories of errors that can be handled by hardhat cli.
@@ -69,6 +70,11 @@ export function printErrorMessages(
   shouldShowStackTraces: boolean = false,
   print: (message: string | Error) => void = console.error,
 ): void {
+  if (error instanceof UsingHardhat2PluginError) {
+    printUsingHardhat2Error(error, print);
+    return;
+  }
+
   const showStackTraces =
     shouldShowStackTraces ||
     getErrorWithCategory(error).category === ErrorCategory.OTHER;
@@ -146,3 +152,15 @@ function getErrorMessages(error: Error): ErrorMessages {
       };
   }
 }
+function printUsingHardhat2Error(
+  error: UsingHardhat2PluginError,
+  print: (message: string | Error) => void = console.error,
+): void {
+  print(chalk.red.bold(`Hardhat 3 installation error:`));
+  print("");
+  if (error.callerRelativePath !== undefined) {
+    print(error.message);
+  } else {
+    print(error.stack);
+  }
+}

package/src/internal/cli/telemetry/sentry/reporter.ts

@@ -8,6 +8,7 @@ import {
   ProviderError,
   UnknownError,
 } from "../../../builtin-plugins/network-manager/provider-errors.js";
+import { UsingHardhat2PluginError } from "../../../using-hardhat2-plugin-errors.js";
 import { getHardhatVersion } from "../../../utils/package.js";
 import { isTelemetryAllowed } from "../telemetry-permissions.js";
 
@@ -134,6 +135,10 @@ class Reporter {
       return false;
     }
 
+    if (error instanceof UsingHardhat2PluginError) {
+      return false;
+    }
+
     if (HardhatPluginError.isHardhatPluginError(error)) {
       // Don't log errors from third-party plugins
       return false;

package/src/internal/cli/telemetry/sentry/transport.ts

@@ -177,6 +177,7 @@ async function sendSerializedEnvelopeToSentryBackend(
     .filter(Boolean)
     .join(", ");
 
+  // eslint-disable-next-line no-restricted-globals -- TODO: determine whether this should be using undici
   const res = await fetch(ingestUrl, {
     method: "POST",
     headers: {

package/src/internal/core/config-validation.ts

@@ -18,9 +18,9 @@ import {
 } from "../../types/arguments.js";
 import {
   type EmptyTaskDefinition,
+  TaskDefinitionType,
   type NewTaskDefinition,
   type TaskDefinition,
-  TaskDefinitionType,
   type TaskOverrideDefinition,
 } from "../../types/tasks.js";
 
@@ -185,6 +185,7 @@ function validatePath(
 export function validateTasksConfig(
   tasks: TaskDefinition[],
   path: Array<string | number> = [],
+  isPlugin: boolean = false,
 ): HardhatUserConfigValidationError[] {
   const validationErrors: HardhatUserConfigValidationError[] = [];
 
@@ -207,13 +208,13 @@ export function validateTasksConfig(
       }
       case TaskDefinitionType.NEW_TASK: {
         validationErrors.push(
-          ...validateNewTask(task, [...path, "tasks", index]),
+          ...validateNewTask(task, [...path, "tasks", index], isPlugin),
         );
         break;
       }
       case TaskDefinitionType.TASK_OVERRIDE: {
         validationErrors.push(
-          ...validateTaskOverride(task, [...path, "tasks", index]),
+          ...validateTaskOverride(task, [...path, "tasks", index], isPlugin),
         );
         break;
       }
@@ -252,6 +253,7 @@ export function validateEmptyTask(
 export function validateNewTask(
   task: NewTaskDefinition,
   path: Array<string | number>,
+  isPlugin: boolean = false,
 ): HardhatUserConfigValidationError[] {
   const validationErrors: HardhatUserConfigValidationError[] = [];
 
@@ -272,13 +274,7 @@ export function validateNewTask(
     });
   }
 
-  if (typeof task.action !== "function") {
-    validationErrors.push({
-      path: [...path, "action"],
-      message:
-        "task action must be a lazy import function returning a module with a default export",
-    });
-  }
+  validationErrors.push(...validateActionFields(task, path, isPlugin));
 
   if (isObject(task.options)) {
     validationErrors.push(
@@ -308,6 +304,7 @@ export function validateNewTask(
 export function validateTaskOverride(
   task: TaskOverrideDefinition,
   path: Array<string | number>,
+  isPlugin: boolean = false,
 ): HardhatUserConfigValidationError[] {
   const validationErrors: HardhatUserConfigValidationError[] = [];
 
@@ -328,13 +325,7 @@ export function validateTaskOverride(
     });
   }
 
-  if (typeof task.action !== "function") {
-    validationErrors.push({
-      path: [...path, "action"],
-      message:
-        "task action must be a lazy import function returning a module with a default export",
-    });
-  }
+  validationErrors.push(...validateActionFields(task, path, isPlugin));
 
   if (isObject(task.options)) {
     validationErrors.push(
@@ -350,6 +341,60 @@ export function validateTaskOverride(
   return validationErrors;
 }
 
+function validateActionFields(
+  task: { action?: unknown; inlineAction?: unknown },
+  path: Array<string | number>,
+  isPlugin: boolean = false,
+): HardhatUserConfigValidationError[] {
+  const validationErrors: HardhatUserConfigValidationError[] = [];
+
+  // Mutual exclusivity: cannot have both action and inlineAction
+  if (task.action !== undefined && task.inlineAction !== undefined) {
+    validationErrors.push({
+      path: [...path],
+      message: 'task cannot define both "action" and "inlineAction"',
+    });
+  }
+
+  if (isPlugin && task.inlineAction !== undefined) {
+    validationErrors.push({
+      path: [...path, "inlineAction"],
+      message:
+        "plugins cannot use inline actions. Use a lazy action import instead",
+    });
+  }
+
+  // At least one action must be defined
+  if (task.action === undefined && task.inlineAction === undefined) {
+    validationErrors.push({
+      path: [...path, "action"],
+      message: 'task must define either "action" or "inlineAction"',
+    });
+  }
+
+  if (task.action !== undefined) {
+    if (typeof task.action !== "function") {
+      validationErrors.push({
+        path: [...path, "action"],
+        message:
+          "task action must be a lazy import function returning a module with a default export",
+      });
+    }
+  }
+
+  if (task.inlineAction !== undefined) {
+    if (typeof task.inlineAction !== "function") {
+      validationErrors.push({
+        path: [...path, "inlineAction"],
+        message:
+          "task inlineAction must be a function implementing the task's behavior",
+      });
+    }
+  }
+
+  return validationErrors;
+}
+
 export function validateOptions(
   options: Record<string, OptionDefinition>,
   path: Array<string | number>,
@@ -665,7 +710,11 @@ export function validatePluginsConfig(
     if (plugin.tasks !== undefined) {
       if (Array.isArray(plugin.tasks)) {
         validationErrors.push(
-          ...validateTasksConfig(plugin.tasks, [...path, "plugins", index]),
+          ...validateTasksConfig(
+            plugin.tasks,
+            [...path, "plugins", index],
+            true,
+          ),
         );
       } else {
         validationErrors.push({

package/src/internal/core/tasks/builders.ts

@@ -15,6 +15,8 @@ import type {
   ExtendTaskArguments,
   TaskArguments,
   LazyActionObject,
+  TaskAction,
+  TaskOverrideAction,
 } from "../../../types/tasks.js";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
@@ -54,7 +56,11 @@ export class EmptyTaskDefinitionBuilderImplementation
 
 export class NewTaskDefinitionBuilderImplementation<
   TaskArgumentsT extends TaskArguments = TaskArguments,
-> implements NewTaskDefinitionBuilder<TaskArgumentsT>
+  ActionTypeT extends
+    | "LAZY_ACTION"
+    | "INLINE_ACTION"
+    | "MISSING_ACTION" = "MISSING_ACTION",
+> implements NewTaskDefinitionBuilder<TaskArgumentsT, ActionTypeT>
 {
   readonly #id: string[];
   readonly #usedNames: Set<string> = new Set();
@@ -65,6 +71,7 @@ export class NewTaskDefinitionBuilderImplementation<
   #description: string;
 
   #action?: LazyActionObject<NewTaskActionFunction<TaskArgumentsT>>;
+  #inlineAction?: NewTaskActionFunction<TaskArgumentsT>;
 
   constructor(id: string | string[], description: string = "") {
     validateId(id);
@@ -80,10 +87,26 @@ export class NewTaskDefinitionBuilderImplementation<
 
   public setAction(
     action: LazyActionObject<NewTaskActionFunction<TaskArgumentsT>>,
-  ): this {
+  ): NewTaskDefinitionBuilder<TaskArgumentsT, "LAZY_ACTION"> {
+    this.#ensureNoActionSet();
+
     this.#action = action;
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the ActionTypeT to the expected type for this scenario. */
+    return this as NewTaskDefinitionBuilder<TaskArgumentsT, "LAZY_ACTION">;
+  }
+
+  public setInlineAction(
+    inlineAction: NewTaskActionFunction<TaskArgumentsT>,
+  ): NewTaskDefinitionBuilder<TaskArgumentsT, "INLINE_ACTION"> {
+    this.#ensureNoActionSet();
+
+    this.#inlineAction = inlineAction;
+
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the ActionTypeT to the expected type for this scenario. */
+    return this as NewTaskDefinitionBuilder<TaskArgumentsT, "INLINE_ACTION">;
   }
 
   public addOption<
@@ -104,7 +127,8 @@ export class NewTaskDefinitionBuilderImplementation<
     defaultValue: ArgumentTypeToValueType<TypeT>;
     hidden?: boolean;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+    ActionTypeT
   > {
     const argumentType = type ?? ArgumentType.STRING;
 
@@ -121,7 +145,13 @@ export class NewTaskDefinitionBuilderImplementation<
 
     this.#options[name] = optionDefinition;
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the generic argument types. Propagate 'ActionTypeT' to preserve
+    the current action state for subsequent method calls. */
+    return this as NewTaskDefinitionBuilder<
+      ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+      ActionTypeT
+    >;
   }
 
   public addFlag<NameT extends string>(flagConfig: {
@@ -130,7 +160,8 @@ export class NewTaskDefinitionBuilderImplementation<
     description?: string;
     hidden?: boolean;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, ArgumentType.FLAG, TaskArgumentsT>
+    ExtendTaskArguments<NameT, ArgumentType.FLAG, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.addOption({
       ...flagConfig,
@@ -146,7 +177,8 @@ export class NewTaskDefinitionBuilderImplementation<
     description?: string;
     defaultValue?: number;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, ArgumentType.LEVEL, TaskArgumentsT>
+    ExtendTaskArguments<NameT, ArgumentType.LEVEL, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.addOption({
       ...levelConfig,
@@ -164,7 +196,8 @@ export class NewTaskDefinitionBuilderImplementation<
     type?: TypeT;
     defaultValue?: ArgumentTypeToValueType<TypeT>;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.#addPositionalArgument({
       ...argConfig,
@@ -181,7 +214,8 @@ export class NewTaskDefinitionBuilderImplementation<
     type?: TypeT;
     defaultValue?: Array<ArgumentTypeToValueType<TypeT>>;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT[], TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.#addPositionalArgument({
       ...argConfig,
@@ -189,8 +223,15 @@ export class NewTaskDefinitionBuilderImplementation<
     });
   }
 
-  public build(): NewTaskDefinition {
-    if (this.#action === undefined) {
+  public build(): ActionTypeT extends "LAZY_ACTION"
+    ? Extract<
+        NewTaskDefinition,
+        { action: LazyActionObject<NewTaskActionFunction> }
+      >
+    : ActionTypeT extends "INLINE_ACTION"
+      ? Extract<NewTaskDefinition, { inlineAction: NewTaskActionFunction }>
+      : never {
+    if (this.#action === undefined && this.#inlineAction === undefined) {
       throw new HardhatError(
         HardhatError.ERRORS.CORE.TASK_DEFINITIONS.NO_ACTION,
         {
@@ -199,18 +240,30 @@ export class NewTaskDefinitionBuilderImplementation<
       );
     }
 
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast the return value because TypeScript cannot verify that the object matches
+    the conditional type. */
     return {
       type: TaskDefinitionType.NEW_TASK,
       id: this.#id,
       description: this.#description,
       /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      -- The type of the action is narrowed in the setAction function to
+      -- The type of the action is narrowed in the setAction function or setInlineAction to
       improve the argument types. Once the task is built, we use the more
       general type to avoid having to parameterize the NewTaskDefinition */
-      action: this.#action as LazyActionObject<NewTaskActionFunction>,
+      ...((this.#action !== undefined
+        ? { action: this.#action }
+        : { inlineAction: this.#inlineAction }) as TaskAction),
       options: this.#options,
       positionalArguments: this.#positionalArgs,
-    };
+    } as ActionTypeT extends "LAZY_ACTION"
+      ? Extract<
+          NewTaskDefinition,
+          { action: LazyActionObject<NewTaskActionFunction> }
+        >
+      : ActionTypeT extends "INLINE_ACTION"
+        ? Extract<NewTaskDefinition, { inlineAction: NewTaskActionFunction }>
+        : never;
   }
 
   #addPositionalArgument<
@@ -231,7 +284,8 @@ export class NewTaskDefinitionBuilderImplementation<
       | Array<ArgumentTypeToValueType<TypeT>>;
     isVariadic: boolean;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+    ActionTypeT
   > {
     const argumentType = type ?? ArgumentType.STRING;
 
@@ -253,13 +307,34 @@ export class NewTaskDefinitionBuilderImplementation<
 
     this.#positionalArgs.push(positionalArgDef);
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the generic argument types. Propagate 'ActionTypeT' to preserve
+    the current action state for subsequent method calls. */
+    return this as NewTaskDefinitionBuilder<
+      ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+      ActionTypeT
+    >;
+  }
+
+  #ensureNoActionSet(): void {
+    if (this.#action !== undefined || this.#inlineAction !== undefined) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.TASK_DEFINITIONS.ACTION_ALREADY_SET,
+        {
+          task: formatTaskId(this.#id),
+        },
+      );
+    }
   }
 }
 
 export class TaskOverrideDefinitionBuilderImplementation<
   TaskArgumentsT extends TaskArguments = TaskArguments,
-> implements TaskOverrideDefinitionBuilder<TaskArgumentsT>
+  ActionTypeT extends
+    | "LAZY_ACTION"
+    | "INLINE_ACTION"
+    | "MISSING_ACTION" = "MISSING_ACTION",
+> implements TaskOverrideDefinitionBuilder<TaskArgumentsT, ActionTypeT>
 {
   readonly #id: string[];
 
@@ -268,6 +343,7 @@ export class TaskOverrideDefinitionBuilderImplementation<
   #description?: string;
 
   #action?: LazyActionObject<TaskOverrideActionFunction<TaskArgumentsT>>;
+  #inlineAction?: TaskOverrideActionFunction<TaskArgumentsT>;
 
   constructor(id: string | string[]) {
     validateId(id);
@@ -282,10 +358,29 @@ export class TaskOverrideDefinitionBuilderImplementation<
 
   public setAction(
     action: LazyActionObject<TaskOverrideActionFunction<TaskArgumentsT>>,
-  ): this {
+  ): TaskOverrideDefinitionBuilder<TaskArgumentsT, "LAZY_ACTION"> {
+    this.#ensureNoActionSet();
+
     this.#action = action;
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the ActionTypeT to the expected type for this scenario. */
+    return this as TaskOverrideDefinitionBuilder<TaskArgumentsT, "LAZY_ACTION">;
+  }
+
+  public setInlineAction(
+    inlineAction: TaskOverrideActionFunction<TaskArgumentsT>,
+  ): TaskOverrideDefinitionBuilder<TaskArgumentsT, "INLINE_ACTION"> {
+    this.#ensureNoActionSet();
+
+    this.#inlineAction = inlineAction;
+
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the ActionTypeT to the expected type for this scenario. */
+    return this as TaskOverrideDefinitionBuilder<
+      TaskArgumentsT,
+      "INLINE_ACTION"
+    >;
   }
 
   public addOption<
@@ -306,7 +401,8 @@ export class TaskOverrideDefinitionBuilderImplementation<
     defaultValue: ArgumentTypeToValueType<TypeT>;
     hidden?: boolean;
   }): TaskOverrideDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+    ActionTypeT
   > {
     const argumentType = type ?? ArgumentType.STRING;
 
@@ -331,16 +427,23 @@ export class TaskOverrideDefinitionBuilderImplementation<
 
     this.#options[name] = optionDefinition;
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the generic argument types. Propagate 'ActionTypeT' to preserve
+    the current action state for subsequent method calls. */
+    return this as TaskOverrideDefinitionBuilder<
+      ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+      ActionTypeT
+    >;
   }
 
   public addFlag<NameT extends string>(flagConfig: {
-    name: string;
+    name: NameT;
     shortName?: string;
     description?: string;
     hidden?: boolean;
   }): TaskOverrideDefinitionBuilder<
-    ExtendTaskArguments<NameT, ArgumentType.FLAG, TaskArgumentsT>
+    ExtendTaskArguments<NameT, ArgumentType.FLAG, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.addOption({
       ...flagConfig,
@@ -351,12 +454,13 @@ export class TaskOverrideDefinitionBuilderImplementation<
   }
 
   public addLevel<NameT extends string>(levelConfig: {
-    name: string;
+    name: NameT;
     shortName?: string;
     description?: string;
     defaultValue?: number;
   }): TaskOverrideDefinitionBuilder<
-    ExtendTaskArguments<NameT, ArgumentType.LEVEL, TaskArgumentsT>
+    ExtendTaskArguments<NameT, ArgumentType.LEVEL, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.addOption({
       ...levelConfig,
@@ -365,8 +469,18 @@ export class TaskOverrideDefinitionBuilderImplementation<
     });
   }
 
-  public build(): TaskOverrideDefinition {
-    if (this.#action === undefined) {
+  public build(): ActionTypeT extends "LAZY_ACTION"
+    ? Extract<
+        TaskOverrideDefinition,
+        { action: LazyActionObject<TaskOverrideActionFunction> }
+      >
+    : ActionTypeT extends "INLINE_ACTION"
+      ? Extract<
+          TaskOverrideDefinition,
+          { inlineAction: TaskOverrideActionFunction }
+        >
+      : never {
+    if (this.#action === undefined && this.#inlineAction === undefined) {
       throw new HardhatError(
         HardhatError.ERRORS.CORE.TASK_DEFINITIONS.NO_ACTION,
         {
@@ -375,16 +489,46 @@ export class TaskOverrideDefinitionBuilderImplementation<
       );
     }
 
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast the return value because TypeScript cannot verify that the object matches
+    the conditional type. */
     return {
       type: TaskDefinitionType.TASK_OVERRIDE,
       id: this.#id,
       description: this.#description,
       /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      -- The type of the action is narrowed in the setAction function to
+      -- The type of the action is narrowed in the setAction function or setInlineAction to
       improve the argument types. Once the task is built, we use the more
       general type to avoid having to parameterize the TaskOverrideDefinition */
-      action: this.#action as LazyActionObject<TaskOverrideActionFunction>,
+      ...((this.#action !== undefined
+        ? {
+            action: this.#action,
+          }
+        : {
+            inlineAction: this.#inlineAction,
+          }) as TaskOverrideAction),
       options: this.#options,
-    };
+    } as ActionTypeT extends "LAZY_ACTION"
+      ? Extract<
+          TaskOverrideDefinition,
+          { action: LazyActionObject<TaskOverrideActionFunction> }
+        >
+      : ActionTypeT extends "INLINE_ACTION"
+        ? Extract<
+            TaskOverrideDefinition,
+            { inlineAction: TaskOverrideActionFunction }
+          >
+        : never;
+  }
+
+  #ensureNoActionSet(): void {
+    if (this.#action !== undefined || this.#inlineAction !== undefined) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.TASK_DEFINITIONS.ACTION_ALREADY_SET,
+        {
+          task: formatTaskId(this.#id),
+        },
+      );
+    }
   }
 }

package/src/internal/core/tasks/resolved-task.ts

@@ -8,6 +8,7 @@ import type {
   LazyActionObject,
   NewTaskActionFunction,
   Task,
+  TaskAction,
   TaskActions,
   TaskArguments,
   TaskOverrideActionFunction,
@@ -36,7 +37,7 @@ export class ResolvedTask implements Task {
     return new ResolvedTask(
       id,
       description,
-      [{ pluginId, action: undefined }],
+      [{ pluginId, action: undefined, inlineAction: undefined }],
       new Map(),
       [],
       pluginId,
@@ -49,7 +50,7 @@ export class ResolvedTask implements Task {
     hre: HardhatRuntimeEnvironment,
     id: string[],
     description: string,
-    action: LazyActionObject<NewTaskActionFunction>,
+    taskAction: TaskAction,
     options: Record<string, OptionDefinition>,
     positionalArguments: PositionalArgumentDefinition[],
     pluginId?: string,
@@ -57,7 +58,12 @@ export class ResolvedTask implements Task {
     return new ResolvedTask(
       id,
       description,
-      [{ pluginId, action }],
+      [
+        {
+          pluginId,
+          ...taskAction,
+        },
+      ],
       new Map(Object.entries(options)),
       positionalArguments,
       pluginId,
@@ -80,7 +86,11 @@ export class ResolvedTask implements Task {
   }
 
   public get isEmpty(): boolean {
-    return this.actions.length === 1 && this.actions[0].action === undefined;
+    return (
+      this.actions.length === 1 &&
+      this.actions[0].action === undefined &&
+      this.actions[0].inlineAction === undefined
+    );
   }
 
   /**
@@ -142,17 +152,25 @@ export class ResolvedTask implements Task {
       nextTaskArguments: TaskArguments,
       currentIndex = this.actions.length - 1,
     ): Promise<any> => {
+      const currentTaskAction = this.actions[currentIndex];
+
+      let actionFn: NewTaskActionFunction | TaskOverrideActionFunction;
+
       // The first action may be empty if the task was originally an empty task
-      const currentAction =
-        this.actions[currentIndex].action ??
-        (async () => ({
-          default: () => {},
-        }));
+      if (currentTaskAction.inlineAction !== undefined) {
+        actionFn = currentTaskAction.inlineAction;
+      } else {
+        const action =
+          currentTaskAction.action ??
+          (async () => ({
+            default: () => {},
+          }));
 
-      const actionFn = await this.#resolveImportAction(
-        currentAction,
-        this.actions[currentIndex].pluginId,
-      );
+        actionFn = await this.#resolveImportAction(
+          action,
+          currentTaskAction.pluginId,
+        );
+      }
 
       if (currentIndex === 0) {
         /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --