ic-mops 2.14.1 → 2.15.1

package/commands/deployed.ts

@@ -0,0 +1,162 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { copyFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { cliError } from "../error.js";
+import {
+  filterCanisters,
+  resolveCanisterConfigs,
+} from "../helpers/resolve-canisters.js";
+import {
+  getRootDir,
+  readConfig,
+  resolveConfigPath,
+  writeConfig,
+} from "../mops.js";
+import { CanisterConfig, Config } from "../types.js";
+import { resolveBuildOutputDir } from "./build.js";
+
+export const DEFAULT_DEPLOYED_DIR = "deployed";
+
+const EMPTY_ACTOR_MOST = "// Version: 1.0.0\nactor { };\n";
+
+export interface DeployedOptions {
+  buildDir?: string;
+  dir?: string;
+}
+
+export interface DeployedInitOptions {
+  dir?: string;
+}
+
+// `[deployed].dir` and CLI overrides are tracked in two forms:
+//   - `config`: relative to mops.toml, used for display + writing into mops.toml
+//   - `resolved`: relative to cwd, used for fs operations
+function resolveDeployedDir(
+  config: Config,
+  override: string | undefined,
+): { config: string; resolved: string } {
+  if (override) {
+    const configRel =
+      path.relative(getRootDir(), path.resolve(override)) || ".";
+    return { config: configRel, resolved: override };
+  }
+  const configured = config.deployed?.dir ?? DEFAULT_DEPLOYED_DIR;
+  return { config: configured, resolved: resolveConfigPath(configured) };
+}
+
+function selectCanisters(
+  canisterNames: string[] | undefined,
+  config: Config,
+): Record<string, CanisterConfig> {
+  if (canisterNames?.length === 0) {
+    cliError("No canisters specified");
+  }
+  const canisters = resolveCanisterConfigs(config);
+  if (!Object.keys(canisters).length) {
+    cliError(`No Motoko canisters found in mops.toml configuration`);
+  }
+  return filterCanisters(canisters, canisterNames);
+}
+
+function warnIfStablePathDiverges(
+  name: string,
+  stablePath: string,
+  destMostRel: string,
+): void {
+  if (
+    path.resolve(resolveConfigPath(stablePath)) ===
+    path.resolve(resolveConfigPath(destMostRel))
+  ) {
+    return;
+  }
+  console.warn(
+    chalk.yellow(
+      `WARN: [canisters.${name}.check-stable].path = "${stablePath}" ` +
+        `does not match where \`mops deployed\` writes ("${destMostRel}"). ` +
+        `\`mops check-stable\` won't see updates from \`mops deployed\`.`,
+    ),
+  );
+}
+
+export async function deployed(
+  canisterNames: string[] | undefined,
+  options: DeployedOptions = {},
+): Promise<void> {
+  const config = readConfig();
+  const filtered = selectCanisters(canisterNames, config);
+
+  const buildDir = resolveBuildOutputDir(config, options.buildDir);
+  const deployedDir = resolveDeployedDir(config, options.dir);
+
+  mkdirSync(deployedDir.resolved, { recursive: true });
+
+  for (const [name, canister] of Object.entries(filtered)) {
+    const sourceMost = path.join(buildDir, `${name}.most`);
+    const destMostRel = path.join(deployedDir.config, `${name}.most`);
+    const destMost = path.join(deployedDir.resolved, `${name}.most`);
+
+    if (!existsSync(sourceMost)) {
+      cliError(
+        `No built .most at ${sourceMost}. Run \`mops build ${name}\` first.`,
+      );
+    }
+
+    await copyFile(sourceMost, destMost);
+    console.log(chalk.green(`✓ ${sourceMost} → ${destMost}`));
+
+    const stablePath = canister["check-stable"]?.path;
+    if (stablePath) {
+      warnIfStablePathDiverges(name, stablePath, destMostRel);
+    }
+  }
+}
+
+export async function deployedInit(
+  canisterNames: string[] | undefined,
+  options: DeployedInitOptions = {},
+): Promise<void> {
+  const config = readConfig();
+  const filtered = selectCanisters(canisterNames, config);
+
+  const deployedDir = resolveDeployedDir(config, options.dir);
+
+  mkdirSync(deployedDir.resolved, { recursive: true });
+
+  let configChanged = false;
+
+  for (const [name, canister] of Object.entries(filtered)) {
+    const destMostRel = path.join(deployedDir.config, `${name}.most`);
+    const destMost = path.join(deployedDir.resolved, `${name}.most`);
+
+    if (!existsSync(destMost)) {
+      await writeFile(destMost, EMPTY_ACTOR_MOST);
+      console.log(chalk.green(`✓ Created baseline ${destMost}`));
+    }
+
+    const stablePath = canister["check-stable"]?.path;
+    if (!stablePath) {
+      const entry = config.canisters?.[name];
+      if (typeof entry === "string") {
+        config.canisters![name] = {
+          main: entry,
+          "check-stable": { path: destMostRel },
+        };
+      } else if (entry) {
+        entry["check-stable"] = { path: destMostRel };
+      }
+      configChanged = true;
+      console.log(
+        chalk.green(
+          `✓ Set [canisters.${name}.check-stable].path = "${destMostRel}"`,
+        ),
+      );
+    } else {
+      warnIfStablePathDiverges(name, stablePath, destMostRel);
+    }
+  }
+
+  if (configChanged) {
+    writeConfig(config);
+  }
+}

package/commands/generate.ts

@@ -0,0 +1,201 @@
+import chalk from "chalk";
+import { execa } from "execa";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { cliError } from "../error.js";
+import {
+  filterCanisters,
+  resolveCanisterConfigs,
+} from "../helpers/resolve-canisters.js";
+import {
+  GENERATE_CANDID_MANAGED_FLAGS,
+  prepareMocArgs,
+} from "../helpers/moc-args.js";
+import {
+  getRootDir,
+  readConfig,
+  resolveConfigPath,
+  writeConfig,
+} from "../mops.js";
+import { CanisterConfig } from "../types.js";
+import { toolchain } from "./toolchain/index.js";
+
+export interface GenerateCandidOptions {
+  output?: string;
+  verbose?: boolean;
+  extraArgs?: string[];
+}
+
+export async function generateCandid(
+  canisterNames: string[] | undefined,
+  options: GenerateCandidOptions,
+): Promise<void> {
+  if (canisterNames?.length === 0) {
+    cliError("No canisters specified");
+  }
+
+  const config = readConfig();
+  const canisters = resolveCanisterConfigs(config);
+  if (!Object.keys(canisters).length) {
+    cliError("No Motoko canisters found in mops.toml configuration");
+  }
+
+  const filtered = filterCanisters(canisters, canisterNames);
+  const filteredEntries = Object.entries(filtered);
+
+  if (options.output && filteredEntries.length > 1) {
+    cliError(
+      "--output / -o is only supported when generating for a single canister",
+    );
+  }
+
+  const mocPath = await toolchain.bin("moc", { fallback: true });
+  const rootDir = getRootDir();
+
+  let configChanged = false;
+
+  for (const [canisterName, canister] of filteredEntries) {
+    const dest = resolveDestination(
+      canisterName,
+      canister,
+      canisters,
+      options.output,
+      rootDir,
+    );
+
+    console.log(
+      chalk.blue("generate candid"),
+      chalk.bold(canisterName),
+      chalk.gray(`→ ${dest.fsPath}`),
+    );
+
+    const prepared = await prepareMocArgs(config, canister, canisterName, {
+      mode: "build",
+      managedFlags: GENERATE_CANDID_MANAGED_FLAGS,
+      commandName: "mops generate candid",
+      verbose: options.verbose,
+      extraArgs: options.extraArgs,
+    });
+
+    try {
+      await mkdir(path.dirname(dest.fsPath), { recursive: true });
+      const args = [
+        "--idl",
+        "-o",
+        dest.fsPath,
+        prepared.motokoPath,
+        ...prepared.args,
+      ];
+      if (options.verbose) {
+        console.log(chalk.gray(mocPath, JSON.stringify(args)));
+      }
+      const result = await execa(mocPath, args, {
+        stdio: options.verbose ? "inherit" : "pipe",
+        reject: false,
+      });
+
+      if (result.exitCode !== 0) {
+        if (!options.verbose) {
+          if (result.stderr) {
+            console.error(chalk.red(result.stderr));
+          }
+          if (result.stdout?.trim()) {
+            console.error(chalk.yellow("Output:"));
+            console.error(result.stdout);
+          }
+        }
+        cliError(
+          `Failed to generate Candid for canister ${canisterName} (exit code: ${result.exitCode})`,
+        );
+      }
+
+      if (dest.configPath !== null) {
+        const c = (config.canisters ??= {});
+        const existing = c[canisterName];
+        const obj: CanisterConfig =
+          typeof existing === "string"
+            ? { main: existing }
+            : { ...(existing ?? {}) };
+        obj.candid = dest.configPath;
+        c[canisterName] = obj;
+        configChanged = true;
+      }
+    } finally {
+      await prepared.cleanup();
+    }
+  }
+
+  if (configChanged) {
+    writeConfig(config);
+  }
+
+  console.log(
+    chalk.green(
+      `\n✓ Generated Candid for ${filteredEntries.length} canister${filteredEntries.length === 1 ? "" : "s"}`,
+    ),
+  );
+}
+
+interface Destination {
+  /** Path used for filesystem operations and passed to moc (cwd-relative or absolute). */
+  fsPath: string;
+  /** Value to write into `[canisters.<name>].candid` (project-root-relative). `null` skips the config update. */
+  configPath: string | null;
+}
+
+function resolveDestination(
+  canisterName: string,
+  canister: CanisterConfig,
+  allCanisters: Record<string, CanisterConfig>,
+  outputFlag: string | undefined,
+  rootDir: string,
+): Destination {
+  if (!canister.main) {
+    cliError(`No main file is specified for canister ${canisterName}`);
+  }
+
+  let fsPath: string;
+  let configPath: string | null;
+
+  if (outputFlag) {
+    fsPath = outputFlag;
+    configPath = null;
+
+    const outAbs = path.resolve(fsPath);
+    for (const [otherName, other] of Object.entries(allCanisters)) {
+      if (otherName === canisterName || !other.candid) {
+        continue;
+      }
+      if (path.resolve(rootDir, other.candid) === outAbs) {
+        console.warn(
+          chalk.yellow(
+            `Warning: --output path collides with [canisters.${otherName}].candid (${other.candid}). Sharing a .did between canisters is almost always a mistake.`,
+          ),
+        );
+      }
+    }
+  } else if (canister.candid) {
+    fsPath = resolveConfigPath(canister.candid);
+    configPath = null;
+  } else {
+    // Default: <dirname(main)>/<canisterName>.did, forward slashes for the toml value
+    const mainDir = path.dirname(canister.main).replace(/\\/g, "/");
+    const projectRel =
+      mainDir === "." || mainDir === ""
+        ? `${canisterName}.did`
+        : `${mainDir}/${canisterName}.did`;
+    fsPath = resolveConfigPath(projectRel);
+    configPath = projectRel;
+  }
+
+  const absPath = path.resolve(fsPath);
+  const dotMopsDir = path.resolve(rootDir, ".mops");
+  if (absPath === dotMopsDir || absPath.startsWith(dotMopsDir + path.sep)) {
+    cliError(
+      `Refusing to write Candid file inside .mops/ (private build cache): ${fsPath}\n` +
+        "Choose a path outside .mops/ — it should be committable and readable by downstream tooling.",
+    );
+  }
+
+  return { fsPath, configPath };
+}

package/commands/lint.ts

@@ -103,6 +103,8 @@ export interface LintOptions {
   rules?: string[];
   files?: string[];
   extraArgs: string[];
+  /** Commander `--no-check-limit`: lint the full migration chain. */
+  noCheckLimit?: boolean;
 }
 
 function buildCommonArgs(
@@ -193,9 +195,10 @@ async function lintImpl(
     : "lintoko";
 
   const isExplicit = !!filter || !!(options.files && options.files.length > 0);
-  const trimmedMigrations = isExplicit
-    ? new Set<string>()
-    : getTrimmedMigrationFiles(config);
+  const trimmedMigrations =
+    isExplicit || options.noCheckLimit
+      ? new Set<string>()
+      : getTrimmedMigrationFiles(config);
 
   let filesToLint: string[];
   if (options.files && options.files.length > 0) {

package/dist/cli.js

@@ -12,9 +12,11 @@ import { bump } from "./commands/bump.js";
 import { check } from "./commands/check.js";
 import { checkCandid } from "./commands/check-candid.js";
 import { checkStable } from "./commands/check-stable.js";
+import { deployed, deployedInit } from "./commands/deployed.js";
 import { docsCoverage } from "./commands/docs-coverage.js";
 import { docs } from "./commands/docs.js";
 import { format } from "./commands/format.js";
+import { generateCandid } from "./commands/generate.js";
 import { info } from "./commands/info.js";
 import { init } from "./commands/init.js";
 import { lint } from "./commands/lint.js";
@@ -60,6 +62,16 @@ function parseExtraArgs(variadicArgs) {
         : [];
     return { extraArgs, args };
 }
+// Shared `--help` section describing the enhanced migration `check-limit`
+// trimming and its override flag, so the limit behaviour is discoverable
+// from `--help`. `withFix` appends the `--fix` hint for commands that support it.
+function enhancedMigrationHelp(withFix) {
+    const example = withFix ? " (e.g. to --fix older migrations)" : "";
+    return ("\nEnhanced migration ([canisters.<name>.migrations]):\n" +
+        "  The canister is checked against its migration chain. [migrations].check-limit\n" +
+        "  trims it to the last N migrations (older ones are skipped). Pass --no-check-limit\n" +
+        `  to use the full chain${example}.`);
+}
 program.name("mops");
 // --version
 program.version(`CLI ${version()}\nAPI ${apiVersion}`, "-v --version");
@@ -76,7 +88,7 @@ program
     .command("add <pkg>")
     .description("Install the package and save it to mops.toml")
     .option("--dev", "Add to [dev-dependencies] section")
-    .option("--verbose")
+    .option("--verbose", "Show more information")
     .addOption(new Option("--lock <action>", "Lockfile action").choices([
     "update",
     "ignore",
@@ -111,7 +123,7 @@ program
     .alias("i")
     .description("Install all dependencies specified in mops.toml")
     .option("--no-toolchain", "Do not install toolchain")
-    .option("--verbose")
+    .option("--verbose", "Show more information")
     .addOption(new Option("--lock <action>", "Lockfile action").choices([
     "check",
     "update",
@@ -145,7 +157,7 @@ program
     .option("--no-docs", "Do not generate docs")
     .option("--no-test", "Do not run tests")
     .option("--no-bench", "Do not run benchmarks")
-    .option("--verbose")
+    .option("--verbose", "Show more information")
     .action(async (options) => {
     if (!checkConfigFile()) {
         process.exit(1);
@@ -247,6 +259,12 @@ program
     .description("Build a canister")
     .addOption(new Option("--verbose", "Verbose console output"))
     .addOption(new Option("--output, -o <output>", "Output directory"))
+    .addHelpText("after", "\nArguments after -- are forwarded directly to moc, e.g.:\n  $ mops build -- -Werror")
+    .addHelpText("after", "\nEnhanced migration ([canisters.<name>.migrations]):\n" +
+    "  The canister is built against its full migration chain (every migration is\n" +
+    "  compiled into the wasm). If mops check passes but mops build fails while\n" +
+    "  [migrations].check-limit is set, re-run with mops check --no-check-limit to\n" +
+    "  surface the issue (check trims the chain; build compiles all of it).")
     .allowUnknownOption(true) // TODO: restrict unknown before "--"
     .action(async (canisters, options) => {
     checkConfigFile(true);
@@ -268,6 +286,9 @@ program
     .description("Check Motoko canisters or files for syntax errors and type issues. Arguments can be canister names or file paths. If no arguments are given, checks all canisters from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured, and runs linting if lintoko is configured in [toolchain]")
     .option("--verbose", "Verbose console output")
     .addOption(new Option("--fix", "Apply autofixes to all files, including transitively imported ones"))
+    .addOption(new Option("--no-check-limit", "Check the full migration chain, ignoring [migrations].check-limit"))
+    .addHelpText("after", "\nArguments after -- are forwarded directly to moc, e.g.:\n  $ mops check -- -Werror")
+    .addHelpText("after", enhancedMigrationHelp(true))
     .allowUnknownOption(true)
     .action(async (args, options) => {
     checkConfigFile(true);
@@ -300,6 +321,9 @@ program
     .command("check-stable [args...]")
     .description("Check stable variable compatibility. With no arguments, checks all canisters with [check-stable] configured. Arguments can be canister names or an old file path followed by an optional canister name")
     .option("--verbose", "Verbose console output")
+    .addOption(new Option("--no-check-limit", "Check the full migration chain, ignoring [migrations].check-limit"))
+    .addHelpText("after", "\nArguments after -- are forwarded directly to moc, e.g.:\n  $ mops check-stable -- -Werror")
+    .addHelpText("after", enhancedMigrationHelp(false))
     .allowUnknownOption(true)
     .action(async (args, options) => {
     checkConfigFile(true);
@@ -314,6 +338,25 @@ program
         extraArgs,
     });
 });
+// deployed
+const deployedCommand = new Command("deployed")
+    .description("Post-deploy hook: promote .most stable-types files into the deployed directory so `mops check-stable` compares against the just-deployed version. Pass canister names to scope; with no arguments, all canisters in mops.toml are promoted")
+    .argument("[canisters...]")
+    .addOption(new Option("--build-dir <dir>", "Directory to read built .most files from (default: [build].outputDir or .mops/.build)"))
+    .addOption(new Option("--dir <dir>", "Destination directory (default: [deployed].dir or deployed)"))
+    .action(async (canisters, options) => {
+    checkConfigFile(true);
+    await deployed(canisters.length ? canisters : undefined, options);
+});
+deployedCommand
+    .command("init [canisters...]")
+    .description("Pre-first-deploy bootstrap: create an empty-actor .most baseline in the deployed directory and wire [canisters.<name>.check-stable].path to it. Idempotent")
+    .addOption(new Option("--dir <dir>", "Destination directory (default: [deployed].dir or deployed)"))
+    .action(async (canisters, options) => {
+    checkConfigFile(true);
+    await deployedInit(canisters.length ? canisters : undefined, options);
+});
+program.addCommand(deployedCommand);
 // test
 program
     .command("test [filter]")
@@ -350,7 +393,7 @@ program
     .addOption(new Option("--save", "Save benchmark results to .bench/<filename>.json"))
     .addOption(new Option("--compare", "Run benchmark and compare results with .bench/<filename>.json"))
     // .addOption(new Option('--force-gc', 'Force GC'))
-    .addOption(new Option("--verbose", "Show more information"))
+    .addOption(new Option("--verbose", "Print the benchmark pipeline (compiler, replica, GC, optimization) and stream compiler/replica output, including dfx optimization warnings"))
     .action(async (filter, options) => {
     checkConfigFile(true);
     await installAll({
@@ -574,6 +617,31 @@ migrateCommand
     await migrateFreeze(canister);
 });
 program.addCommand(migrateCommand);
+// generate
+const generateCommand = new Command("generate")
+    .description("Generate source-derived artifacts (Candid, ...)")
+    .showHelpAfterError();
+generateCommand
+    .command("candid [canisters...]")
+    .description("(Re)generate the curated `.did` file for one or more canisters from current Motoko source. With no canister names, generates for all canisters in mops.toml. When [canisters.<name>].candid is set, overwrites that file; otherwise writes <name>.did next to `main` and sets the field.")
+    .addOption(new Option("--output, -o <output>", "Write the generated .did to <output> (single-canister only; does not touch mops.toml)"))
+    .addOption(new Option("--verbose", "Verbose console output"))
+    .addHelpText("after", "\nArguments after -- are forwarded directly to moc, e.g.:\n  $ mops generate candid -- -Werror")
+    .allowUnknownOption(true)
+    .action(async (canisters, options) => {
+    checkConfigFile(true);
+    const { extraArgs, args } = parseExtraArgs(canisters);
+    await installAll({
+        silent: true,
+        lock: "ignore",
+        installFromLockFile: true,
+    });
+    await generateCandid(args.length ? args : undefined, {
+        ...options,
+        extraArgs,
+    });
+});
+program.addCommand(generateCommand);
 // self
 const selfCommand = new Command("self").description("Mops CLI management");
 selfCommand
@@ -623,6 +691,9 @@ program
     .addOption(new Option("--verbose", "Verbose output"))
     .addOption(new Option("--fix", "Apply fixes"))
     .addOption(new Option("-r, --rules <directory...>", "Directories containing rules (can be used multiple times)"))
+    .addOption(new Option("--no-check-limit", "Lint the full migration chain, ignoring [migrations].check-limit"))
+    .addHelpText("after", "\nArguments after -- are forwarded directly to lintoko, e.g.:\n  $ mops lint -- --severity warning")
+    .addHelpText("after", enhancedMigrationHelp(true))
     .allowUnknownOption(true)
     .action(async (filter, options) => {
     checkConfigFile(true);
@@ -630,6 +701,7 @@ program
     await lint(filter, {
         ...options,
         extraArgs,
+        noCheckLimit: options.checkLimit === false,
     });
 });
 // docs

package/dist/commands/bench-replica.js

@@ -55,7 +55,9 @@ export class BenchReplica {
     }
     async deploy(name, wasm, cwd = process.cwd()) {
         if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
-            await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, { cwd, stdio: this.verbose ? "pipe" : ["pipe", "ignore", "pipe"] });
+            await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, 
+            // `inherit` so dfx output is streamed under --verbose (incl. its `Failed to optimize` warning)
+            { cwd, stdio: this.verbose ? "inherit" : ["pipe", "ignore", "pipe"] });
             let canisterId = execSync(`dfx canister id ${name}`, { cwd })
                 .toString()
                 .trim();

package/dist/commands/bench.js

@@ -61,7 +61,19 @@ export async function bench(filter = "", optionsArg = {}) {
         options.replicaVersion = config.toolchain?.["pocket-ic"] || "";
     }
     warnIfDfxReplica(replicaType, optionsArg.replica === "dfx");
-    options.verbose && console.log(options);
+    if (options.verbose) {
+        // `dfx` post-optimizes the wasm on deploy (`optimize: "cycles"`, via ic-wasm);
+        // `pocket-ic` runs the raw moc output. This changes instruction counts, so surface it.
+        let optimize = replicaType === "dfx" || replicaType === "dfx-pocket-ic"
+            ? 'dfx `optimize: "cycles"` (ic-wasm) on deploy'
+            : "none (raw moc output)";
+        console.log(chalk.gray("Benchmark pipeline:"));
+        console.log(chalk.gray(`  compiler:  moc ${options.compilerVersion}`));
+        console.log(chalk.gray(`  replica:   ${replicaType}${options.replicaVersion ? ` ${options.replicaVersion}` : ""}`));
+        console.log(chalk.gray(`  gc:        ${options.gc}${options.forceGc ? " (forced)" : ""}`));
+        console.log(chalk.gray(`  profile:   ${options.profile}`));
+        console.log(chalk.gray(`  optimize:  ${optimize}`));
+    }
     let replica = new BenchReplica(replicaType, options.verbose);
     let rootDir = getRootDir();
     let globStr = "**/bench?(mark)/**/*.bench.mo";
@@ -207,10 +219,15 @@ async function deployBenchFile(file, options, replica, globalMocArgs) {
     // build canister
     let mocPath = getMocPath();
     let mocArgs = getMocArgs(options);
-    options.verbose && console.time(`build ${canisterName}`);
-    await execaCommand(`${mocPath} -c --idl canister.mo ${globalMocArgs.join(" ")} ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`, {
+    let buildCmd = `${mocPath} -c --idl canister.mo ${globalMocArgs.join(" ")} ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`;
+    if (options.verbose) {
+        console.log(chalk.gray(`[${canisterName}] ${buildCmd}`));
+        console.time(`build ${canisterName}`);
+    }
+    await execaCommand(buildCmd, {
         cwd: tempDir,
-        stdio: options.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
+        // `inherit` so the compiler output (warnings/errors) is streamed under --verbose
+        stdio: options.verbose ? "inherit" : ["pipe", "ignore", "pipe"],
     });
     options.verbose && console.timeEnd(`build ${canisterName}`);
     // deploy canister

package/dist/commands/build.d.ts

@@ -1,7 +1,13 @@
+import { Config } from "../types.js";
 export interface BuildOptions {
     outputDir: string;
     verbose: boolean;
     extraArgs: string[];
 }
 export declare const DEFAULT_BUILD_OUTPUT_DIR = ".mops/.build";
+/**
+ * Resolve the build output directory: CLI override → `[build].outputDir`
+ * (project-root-relative, resolved via `resolveConfigPath`) → default.
+ */
+export declare function resolveBuildOutputDir(config: Config, override?: string): string;
 export declare function build(canisterNames: string[] | undefined, options: Partial<BuildOptions>): Promise<void>;