hardhat 3.2.0 → 3.3.0

package/src/internal/builtin-plugins/solidity-test/inline-config/parsing.ts

@@ -0,0 +1,186 @@
+import type { RawInlineOverride } from "./types.js";
+
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import { isObject } from "@nomicfoundation/hardhat-utils/lang";
+import {
+  kebabToCamelCase,
+  snakeToCamelCase,
+} from "@nomicfoundation/hardhat-utils/string";
+
+import {
+  HARDHAT_CONFIG_PREFIX,
+  FORGE_CONFIG_PREFIX,
+  TOP_LEVEL_KEYS,
+} from "./constants.js";
+import { getFunctionFqn } from "./helpers.js";
+
+/**
+ * Extracts raw inline config overrides from a solc AST for a single source
+ * file.
+ */
+export function extractInlineConfigFromAst(
+  ast: unknown,
+  inputSourceName: string,
+  contractNames: Set<string>,
+): RawInlineOverride[] {
+  if (!isObject(ast) || ast.nodeType !== "SourceUnit") {
+    return [];
+  }
+
+  const results: RawInlineOverride[] = [];
+  const nodes: unknown[] = Array.isArray(ast.nodes) ? ast.nodes : [];
+  for (const node of nodes) {
+    if (!isObject(node) || node.nodeType !== "ContractDefinition") {
+      continue;
+    }
+
+    const contractName = node.name;
+    if (typeof contractName !== "string") {
+      continue;
+    }
+
+    if (!contractNames.has(contractName)) {
+      continue;
+    }
+
+    const members: unknown[] = Array.isArray(node.nodes) ? node.nodes : [];
+    for (const member of members) {
+      if (!isObject(member) || member.nodeType !== "FunctionDefinition") {
+        continue;
+      }
+
+      const fnName = member.name;
+      if (
+        typeof fnName !== "string" ||
+        (!fnName.startsWith("test") && !fnName.startsWith("invariant"))
+      ) {
+        continue;
+      }
+
+      const fnSelector =
+        typeof member.functionSelector === "string"
+          ? member.functionSelector
+          : undefined;
+
+      const docText = extractDocText(member.documentation);
+      if (docText === undefined) {
+        continue;
+      }
+
+      for (const line of docText.split("\n")) {
+        const parsed = parseInlineConfigLine(
+          line,
+          inputSourceName,
+          contractName,
+          fnName,
+        );
+        if (parsed !== undefined) {
+          parsed.functionSelector = fnSelector;
+          results.push(parsed);
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Extracts the documentation text from a FunctionDefinition's documentation
+ * field, which can be a StructuredDocumentation node, a plain string, or null.
+ */
+export function extractDocText(doc: unknown): string | undefined {
+  if (
+    isObject(doc) &&
+    doc.nodeType === "StructuredDocumentation" &&
+    typeof doc.text === "string"
+  ) {
+    return doc.text;
+  } else if (typeof doc === "string") {
+    return doc;
+  } else {
+    return undefined;
+  }
+}
+
+/**
+ * Parses a single line from a NatSpec comment and returns a RawInlineOverride
+ * if the line contains a valid inline config directive. The line must start
+ * with either "hardhat-config:" or "forge-config:", followed by a key=value pair.
+ * Returns undefined if the line does not contain an inline config directive.
+ */
+export function parseInlineConfigLine(
+  line: string,
+  inputSourceName: string,
+  contractName: string,
+  functionName: string,
+): RawInlineOverride | undefined {
+  // Strip leading whitespace and optional leading '*' from NatSpec text.
+  // Solc's StructuredDocumentation.text has delimiters (///, /**, */) removed.
+  // For /// comments, text has leading whitespace; for /** */ blocks, interior
+  // lines may start with " * ". The regex handles both styles.
+  const trimmedLine = line.replace(/^\s*\*?\s*/, "");
+  const functionFqn = getFunctionFqn(
+    inputSourceName,
+    contractName,
+    functionName,
+  );
+
+  let keyValueSegment: string;
+
+  if (trimmedLine.startsWith(HARDHAT_CONFIG_PREFIX)) {
+    keyValueSegment = trimmedLine.slice(HARDHAT_CONFIG_PREFIX.length).trim();
+  } else if (trimmedLine.startsWith(FORGE_CONFIG_PREFIX)) {
+    keyValueSegment = trimmedLine.slice(FORGE_CONFIG_PREFIX.length).trim();
+  } else {
+    return undefined;
+  }
+
+  const eqIndex = keyValueSegment.indexOf("=");
+  if (eqIndex === -1) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_SYNTAX,
+      {
+        line: trimmedLine,
+        functionFqn,
+      },
+    );
+  }
+
+  const rawKey = keyValueSegment.slice(0, eqIndex).trim();
+  let parsedKey = rawKey;
+  const rawValue = keyValueSegment.slice(eqIndex + 1).trim();
+
+  // Detect profile prefix: if the first dot-segment is NOT a known top-level
+  // category, treat it as a profile name.
+  const firstDot = rawKey.indexOf(".");
+  if (firstDot !== -1) {
+    const firstSegment = rawKey.slice(0, firstDot);
+    if (!TOP_LEVEL_KEYS.includes(firstSegment)) {
+      // It's a profile. Validate it.
+      const profile = firstSegment;
+      if (profile !== "default") {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_UNSUPPORTED_PROFILE,
+          {
+            profile,
+            functionFqn,
+          },
+        );
+      }
+      // Strip the "default." prefix
+      parsedKey = rawKey.slice(firstDot + 1);
+    }
+  }
+
+  parsedKey = snakeToCamelCase(kebabToCamelCase(parsedKey));
+
+  return {
+    inputSourceName,
+    contractName,
+    functionName,
+    key: parsedKey,
+    rawKey,
+    rawValue,
+  };
+}

package/src/internal/builtin-plugins/solidity-test/inline-config/types.ts

@@ -0,0 +1,9 @@
+export interface RawInlineOverride {
+  inputSourceName: string;
+  contractName: string;
+  functionName: string;
+  functionSelector?: string; // from AST, hex without 0x prefix
+  key: string; // parsed camelCase key, without profile prefix
+  rawKey: string; // original key as written by the user, for error messages
+  rawValue: string;
+}

package/src/internal/builtin-plugins/solidity-test/inline-config/validation.ts

@@ -0,0 +1,122 @@
+import type { RawInlineOverride } from "./types.js";
+
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+
+import { KEY_TYPES } from "./constants.js";
+import { getFunctionFqn } from "./helpers.js";
+
+/**
+ * Validates a list of raw inline overrides, checking for:
+ * - Valid keys
+ * - No duplicate keys for the same function
+ * - Values of the expected type (numbers must be non-negative integers, booleans
+ *   must be "true" or "false")
+ *
+ * Throws a HardhatError if any validation fails.
+ */
+export function validateInlineOverrides(overrides: RawInlineOverride[]): void {
+  const seen = new Set<string>();
+
+  for (const {
+    inputSourceName,
+    contractName,
+    functionName,
+    functionSelector,
+    rawKey,
+    rawValue,
+    key,
+  } of overrides) {
+    const functionFqn = getFunctionFqn(
+      inputSourceName,
+      contractName,
+      functionName,
+    );
+
+    // Validate key
+    if (!Object.hasOwn(KEY_TYPES, key)) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_KEY,
+        {
+          key: rawKey,
+          validKeys: Object.keys(KEY_TYPES).join(", "),
+          functionFqn,
+        },
+      );
+    }
+
+    // Validate key matches test type
+    const dotIndex = key.indexOf(".");
+    if (dotIndex !== -1) {
+      const keyCategory = key.slice(0, dotIndex);
+      const isFuzzTest = functionName.startsWith("test");
+      const isInvariantTest = functionName.startsWith("invariant");
+
+      if (
+        (isFuzzTest && keyCategory === "invariant") ||
+        (isInvariantTest && keyCategory === "fuzz")
+      ) {
+        const testType = isFuzzTest ? "fuzz" : "invariant";
+        const validPrefix = isFuzzTest ? "fuzz." : "invariant.";
+        const validKeys = Object.keys(KEY_TYPES)
+          .filter((k) => k.startsWith(validPrefix) || !k.includes("."))
+          .join(", ");
+
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_KEY_FOR_TEST_TYPE,
+          {
+            key: rawKey,
+            functionFqn,
+            testType,
+            validKeys,
+          },
+        );
+      }
+    }
+
+    // Check for duplicates (include selector to allow same key on overloaded functions)
+    const functionId =
+      functionSelector !== undefined
+        ? `${functionFqn}#${functionSelector}`
+        : functionFqn;
+    const dedupeKey = `${functionId}-${key}`;
+    if (seen.has(dedupeKey)) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_DUPLICATE_KEY,
+        { key: rawKey, functionFqn },
+      );
+    }
+    seen.add(dedupeKey);
+
+    // Validate value type
+    const expectedType = KEY_TYPES[key];
+    if (expectedType === "number") {
+      if (
+        !/^(0|[1-9]\d*)$/.test(rawValue) ||
+        !Number.isSafeInteger(Number(rawValue))
+      ) {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_VALUE,
+          {
+            value: rawValue,
+            key: rawKey,
+            expectedType: "non-negative integer",
+            functionFqn,
+          },
+        );
+      }
+    } else {
+      const lowerValue = rawValue.toLowerCase();
+      if (lowerValue !== "true" && lowerValue !== "false") {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_VALUE,
+          {
+            value: rawValue,
+            key: rawKey,
+            expectedType: "boolean",
+            functionFqn,
+          },
+        );
+      }
+    }
+  }
+}

package/src/internal/builtin-plugins/solidity-test/reporter.ts

@@ -3,6 +3,7 @@ import type {
   TestReporterResult,
   TestStatus,
 } from "./types.js";
+import type { Colorizer } from "../../utils/colorizer.js";
 import type { TestResult } from "@nomicfoundation/edr";
 
 import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
@@ -11,12 +12,9 @@ import chalk from "chalk";
 import { sendErrorTelemetry } from "../../cli/telemetry/sentry/reporter.js";
 import { SolidityTestStackTraceGenerationError } from "../network-manager/edr/stack-traces/stack-trace-generation-errors.js";
 import { encodeStackTraceEntry } from "../network-manager/edr/stack-traces/stack-trace-solidity-errors.js";
+import { formatTraces } from "../network-manager/edr/utils/trace-formatters.js";
 
-import {
-  type Colorizer,
-  formatArtifactId,
-  formatTraces,
-} from "./formatters.js";
+import { formatArtifactId } from "./formatters.js";
 import { getMessageFromLastStackTraceEntry } from "./stack-trace-solidity-errors.js";
 
 class Indenter {
@@ -147,6 +145,8 @@ export async function* testReporter(
               suiteSuccessCount++;
               if (verbosity >= 5) {
                 printSetUpTraces = true;
+              }
+              if (verbosity >= 4) {
                 printExecutionTraces = true;
               }
               break;
@@ -184,7 +184,7 @@ export async function* testReporter(
               if (printSetUpTraces && functionName === "setUp") {
                 return true;
               }
-              if (printExecutionTraces && functionName !== "setUp()") {
+              if (printExecutionTraces && functionName !== "setUp") {
                 return true;
               }
               return false;

package/src/internal/builtin-plugins/solidity-test/task-action.ts

@@ -1,13 +1,13 @@
-import type { RunOptions } from "./runner.js";
+import type {
+  BuildInfoAndOutput,
+  EdrArtifactWithMetadata,
+} from "./edr-artifacts.js";
 import type { TestEvent } from "./types.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 import type { TestRunResult } from "../../../types/test.js";
 import type { Result } from "../../../types/utils.js";
 import type {
-  Artifact as EdrArtifact,
-  BuildInfoAndOutput,
   ObservabilityConfig,
-  SolidityTestRunnerConfigArgs,
   TracingConfigWithBuffers,
   SuiteResult,
 } from "@nomicfoundation/edr";
@@ -26,13 +26,17 @@ import { getCoverageManager } from "../coverage/helpers.js";
 import { getGasAnalyticsManager } from "../gas-analytics/helpers.js";
 import { edrGasReportToHardhatGasMeasurements } from "../network-manager/edr/utils/convert-to-edr.js";
 
-import { getEdrArtifacts, getBuildInfos } from "./edr-artifacts.js";
+import {
+  buildEdrArtifactsWithMetadata,
+  getBuildInfosAndOutputs,
+} from "./edr-artifacts.js";
 import {
   isTestSuiteArtifact,
   warnDeprecatedTestFail,
   solidityTestConfigToRunOptions,
   solidityTestConfigToSolidityTestRunnerConfigArgs,
 } from "./helpers.js";
+import { getTestFunctionOverrides } from "./inline-config/index.js";
 import { testReporter } from "./reporter.js";
 import { run } from "./runner.js";
 
@@ -41,7 +45,6 @@ interface TestActionArguments {
   chainType: string;
   grep?: string;
   noCompile: boolean;
-  verbosity: number;
   testSummaryIndex: number;
 }
 
@@ -50,12 +53,14 @@ export interface SolidityTestRunResult extends TestRunResult {
 }
 
 const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
-  { testFiles, chainType, grep, noCompile, verbosity, testSummaryIndex },
+  { testFiles, chainType, grep, noCompile, testSummaryIndex },
   hre,
 ): Promise<Result<SolidityTestRunResult, SolidityTestRunResult>> => {
   // Set an environment variable that plugins can use to detect when a process is running tests
   process.env.HH_TEST = "true";
 
+  const verbosity = hre.globalOptions.verbosity;
+
   // Sets the NODE_ENV environment variable to "test" so the code can detect that tests are running
   // This is done by other JS/TS test frameworks like vitest
   process.env.NODE_ENV ??= "test";
@@ -88,26 +93,27 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   console.log();
 
   // EDR needs all artifacts (contracts + tests)
-  const edrArtifacts: Array<{
-    edrArtifact: EdrArtifact;
-    userSourceName: string;
-  }> = [];
-  const buildInfos: BuildInfoAndOutput[] = [];
+  const edrArtifactsWithMetadata: EdrArtifactWithMetadata[] = [];
+  const allBuildInfosAndOutputs: BuildInfoAndOutput[] = [];
   for (const scope of ["contracts", "tests"] as const) {
     const artifactsDir = await hre.solidity.getArtifactsDirectory(scope);
     const artifactManager = new ArtifactManagerImplementation(artifactsDir);
-    edrArtifacts.push(...(await getEdrArtifacts(artifactManager)));
-    buildInfos.push(...(await getBuildInfos(artifactManager)));
+    edrArtifactsWithMetadata.push(
+      ...(await buildEdrArtifactsWithMetadata(artifactManager)),
+    );
+    allBuildInfosAndOutputs.push(
+      ...(await getBuildInfosAndOutputs(artifactManager)),
+    );
   }
 
   const sourceNameToUserSourceName = new Map(
-    edrArtifacts.map(({ userSourceName, edrArtifact }) => [
+    edrArtifactsWithMetadata.map(({ userSourceName, edrArtifact }) => [
       edrArtifact.id.source,
       userSourceName,
     ]),
   );
 
-  edrArtifacts.forEach(({ userSourceName, edrArtifact }) => {
+  edrArtifactsWithMetadata.forEach(({ userSourceName, edrArtifact }) => {
     if (
       testRootPaths.includes(
         resolveFromRoot(hre.config.paths.root, userSourceName),
@@ -118,14 +124,17 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     }
   });
 
-  const testSuiteIds = edrArtifacts
+  const testSuiteArtifacts = edrArtifactsWithMetadata
     .filter(({ userSourceName }) =>
       testRootPaths.includes(
         resolveFromRoot(hre.config.paths.root, userSourceName),
       ),
     )
-    .filter(({ edrArtifact }) => isTestSuiteArtifact(edrArtifact))
-    .map(({ edrArtifact }) => edrArtifact.id);
+    .filter(({ edrArtifact }) => isTestSuiteArtifact(edrArtifact));
+
+  const testSuiteIds = testSuiteArtifacts.map(
+    ({ edrArtifact }) => edrArtifact.id,
+  );
 
   console.log("Running Solidity tests");
   console.log();
@@ -160,7 +169,12 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     }
   }
 
-  const testRunnerConfig: SolidityTestRunnerConfigArgs =
+  const testFunctionOverrides = getTestFunctionOverrides(
+    testSuiteArtifacts,
+    allBuildInfosAndOutputs,
+  );
+
+  const testRunnerConfig =
     await solidityTestConfigToSolidityTestRunnerConfigArgs({
       chainType,
       projectRoot: hre.config.paths.root,
@@ -172,13 +186,16 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
       generateGasReport:
         hre.globalOptions.gasStats ||
         hre.globalOptions.gasStatsJson !== undefined,
+      testFunctionOverrides,
     });
   const tracingConfig: TracingConfigWithBuffers = {
-    buildInfos,
+    buildInfos: allBuildInfosAndOutputs.map(({ buildInfo, output }) => ({
+      buildInfo,
+      output,
+    })),
     ignoreContracts: false,
   };
-  const options: RunOptions =
-    solidityTestConfigToRunOptions(solidityTestConfig);
+  const runOptions = solidityTestConfigToRunOptions(solidityTestConfig);
 
   await hre.hooks.runHandlerChain(
     "test",
@@ -189,12 +206,12 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
 
   const runStream = run(
     chainType,
-    edrArtifacts.map(({ edrArtifact }) => edrArtifact),
+    edrArtifactsWithMetadata.map(({ edrArtifact }) => edrArtifact),
     testSuiteIds,
     testRunnerConfig,
     tracingConfig,
     sourceNameToUserSourceName,
-    options,
+    runOptions,
   );
 
   let failed = 0;

package/src/internal/builtin-plugins/test/index.ts

@@ -1,7 +1,6 @@
 import type { HardhatPlugin } from "../../../types/plugins.js";
 
 import { ArgumentType } from "../../../types/arguments.js";
-import { DEFAULT_VERBOSITY } from "../../constants.js";
 import { task } from "../../core/config.js";
 
 import "./type-extensions.js";
@@ -33,12 +32,6 @@ const hardhatPlugin: HardhatPlugin = {
         name: "noCompile",
         description: "Do not compile the project before running the tests",
       })
-      .addLevel({
-        name: "verbosity",
-        shortName: "v",
-        description: "Verbosity level of the test output",
-        defaultValue: DEFAULT_VERBOSITY,
-      })
       .setAction(async () => import("./task-action.js"))
       .build(),
   ],

package/src/internal/builtin-plugins/test/task-action.ts

@@ -24,7 +24,6 @@ interface TestActionArguments {
   chainType: string;
   grep: string | undefined;
   noCompile: boolean;
-  verbosity: number;
 }
 
 // Old plugins may only return { failed, passed } without skipped/todo,
@@ -51,7 +50,7 @@ function isTestRunResult(
 }
 
 const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
-  { testFiles, chainType, grep, noCompile, verbosity, ...otherArgs },
+  { testFiles, chainType, grep, noCompile, ...otherArgs },
   hre,
 ): Promise<Result<void, void>> => {
   // If this code is executed, it means the user has not specified a test runner.
@@ -107,10 +106,6 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
       args.chainType = chainType;
     }
 
-    if (subtask.options.has("verbosity")) {
-      args.verbosity = verbosity;
-    }
-
     for (const [key, value] of Object.entries(otherArgs)) {
       if (subtask.options.has(key)) {
         args[key] = value;

package/src/internal/cli/help/get-help-string.ts

@@ -1,6 +1,8 @@
 import type { GlobalOptionDefinitions } from "../../../types/global-options.js";
 import type { Task } from "../../../types/tasks.js";
 
+import chalk from "chalk";
+
 import {
   GLOBAL_NAME_PADDING,
   parseOptions,
@@ -15,8 +17,6 @@ export async function getHelpString(
   task: Task,
   globalOptionDefinitions: GlobalOptionDefinitions,
 ): Promise<string> {
-  const { default: chalk } = await import("chalk");
-
   const { options, positionalArguments } = parseOptions(task);
 
   const subtasks = parseSubtasks(task);

package/src/internal/cli/init/init.ts

@@ -29,6 +29,7 @@ import {
   getHardhatVersion,
   getLatestHardhatVersion,
 } from "../../utils/package.js";
+import { BannerManager } from "../banner-manager.js";
 import { sendProjectTypeAnalytics } from "../telemetry/analytics/analytics.js";
 import { sendErrorTelemetry } from "../telemetry/sentry/reporter.js";
 
@@ -133,7 +134,6 @@ export async function initHardhat(options?: InitHardhatOptions): Promise<void> {
     showStarOnGitHubMessage();
 
     try {
-      const { BannerManager } = await import("../banner-manager.js");
       const bannerManager = await BannerManager.getInstance();
       await bannerManager.showBanner();
     } catch (bannerError) {

package/src/internal/cli/init/prompt.ts

@@ -3,14 +3,13 @@ import type { Template } from "./template.js";
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { shortenPath } from "@nomicfoundation/hardhat-utils/path";
 import chalk from "chalk";
+import enquirer from "enquirer";
 
 export async function promptForHardhatVersion(): Promise<
   "hardhat-2" | "hardhat-3"
 > {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const hardhatVersionResponse = await enquirer.prompt<{
     hardhatVersion: "hardhat-2" | "hardhat-3";
   }>([
@@ -40,8 +39,6 @@ export async function promptForHardhatVersion(): Promise<
 export async function promptForWorkspace(): Promise<string> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const workspaceResponse = await enquirer.prompt<{ workspace: string }>([
     {
       name: "workspace",
@@ -59,8 +56,6 @@ export async function promptForMigrateToEsm(
 ): Promise<boolean> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const migrateToEsmResponse = await enquirer.prompt<{ migrateToEsm: boolean }>(
     [
       {
@@ -80,8 +75,6 @@ export async function promptForTemplate(
 ): Promise<string> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const templateResponse = await enquirer.prompt<{ template: string }>([
     {
       name: "template",
@@ -102,8 +95,6 @@ export async function promptForTemplate(
 export async function promptForForce(files: string[]): Promise<boolean> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const forceResponse = await enquirer.prompt<{ force: boolean }>([
     {
       name: "force",
@@ -121,8 +112,6 @@ export async function promptForInstall(
 ): Promise<boolean> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const installResponse = await enquirer.prompt<{ install: boolean }>([
     {
       name: "install",
@@ -140,8 +129,6 @@ export async function promptForUpdate(
 ): Promise<boolean> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const updateResponse = await enquirer.prompt<{ update: boolean }>([
     {
       name: "update",