ic-mops 1.11.1 → 2.0.0

package/dist/commands/bench.d.ts

@@ -1,17 +1,17 @@
-import { Benchmarks } from '../declarations/main/main.did.js';
-type ReplicaName = 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
+import { Benchmarks } from "../declarations/main/main.did.js";
+type ReplicaName = "dfx" | "pocket-ic" | "dfx-pocket-ic";
 type BenchOptions = {
     replica: ReplicaName;
     replicaVersion: string;
-    compiler: 'moc';
+    compiler: "moc";
     compilerVersion: string;
-    gc: 'copying' | 'compacting' | 'generational' | 'incremental';
+    gc: "copying" | "compacting" | "generational" | "incremental";
     forceGc: boolean;
     save: boolean;
     compare: boolean;
     verbose: boolean;
     silent: boolean;
-    profile: 'Debug' | 'Release';
+    profile: "Debug" | "Release";
 };
 export declare function bench(filter?: string, optionsArg?: Partial<BenchOptions>): Promise<Benchmarks>;
 export {};

package/dist/commands/bench.js

@@ -1,88 +1,90 @@
-import process from 'node:process';
-import path from 'node:path';
-import fs from 'node:fs';
-import os from 'node:os';
-import chalk from 'chalk';
-import { globSync } from 'glob';
-import { markdownTable } from 'markdown-table';
-import { createLogUpdate } from 'log-update';
-import { execaCommand } from 'execa';
-import stringWidth from 'string-width';
-import { filesize } from 'filesize';
-import terminalSize from 'terminal-size';
-import { SemVer } from 'semver';
-import { getRootDir, readConfig, readDfxJson } from '../mops.js';
-import { parallel } from '../parallel.js';
-import { absToRel } from './test/utils.js';
-import { getMocVersion } from '../helpers/get-moc-version.js';
-import { getDfxVersion } from '../helpers/get-dfx-version.js';
-import { getMocPath } from '../helpers/get-moc-path.js';
-import { sources } from './sources.js';
-import { BenchReplica } from './bench-replica.js';
+import process from "node:process";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import chalk from "chalk";
+import { globSync } from "glob";
+import { markdownTable } from "markdown-table";
+import { createLogUpdate } from "log-update";
+import { execaCommand } from "execa";
+import stringWidth from "string-width";
+import { filesize } from "filesize";
+import terminalSize from "terminal-size";
+import { SemVer } from "semver";
+import { getRootDir, readConfig, readDfxJson } from "../mops.js";
+import { parallel } from "../parallel.js";
+import { absToRel } from "./test/utils.js";
+import { getMocVersion } from "../helpers/get-moc-version.js";
+import { getDfxVersion } from "../helpers/get-dfx-version.js";
+import { getMocPath } from "../helpers/get-moc-path.js";
+import { sources } from "./sources.js";
+import { BenchReplica } from "./bench-replica.js";
 let ignore = [
-    '**/node_modules/**',
-    '**/.mops/**',
-    '**/.vessel/**',
-    '**/.git/**',
+    "**/node_modules/**",
+    "**/.mops/**",
+    "**/.vessel/**",
+    "**/.git/**",
 ];
 let globConfig = {
     nocase: true,
     ignore: ignore,
 };
-export async function bench(filter = '', optionsArg = {}) {
+export async function bench(filter = "", optionsArg = {}) {
     let config = readConfig();
     let dfxJson = readDfxJson();
     let defaultOptions = {
-        replica: config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx',
-        replicaVersion: '',
-        compiler: 'moc',
+        replica: config.toolchain?.["pocket-ic"] ? "pocket-ic" : "dfx",
+        replicaVersion: "",
+        compiler: "moc",
         compilerVersion: getMocVersion(true),
-        gc: 'copying',
+        gc: "copying",
         forceGc: true,
         save: false,
         compare: false,
         verbose: false,
         silent: false,
-        profile: dfxJson?.profile || 'Release',
+        profile: dfxJson?.profile || "Release",
     };
     let options = { ...defaultOptions, ...optionsArg };
-    let replicaType = options.replica ?? (config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx');
-    if (replicaType === 'pocket-ic' && !config.toolchain?.['pocket-ic']) {
+    let replicaType = options.replica ??
+        (config.toolchain?.["pocket-ic"] ? "pocket-ic" : "dfx");
+    if (replicaType === "pocket-ic" && !config.toolchain?.["pocket-ic"]) {
         let dfxVersion = getDfxVersion();
-        if (!dfxVersion || new SemVer(dfxVersion).compare('0.24.1') < 0) {
-            console.log(chalk.red('Please update dfx to the version >=0.24.1 or specify pocket-ic version in mops.toml'));
+        if (!dfxVersion || new SemVer(dfxVersion).compare("0.24.1") < 0) {
+            console.log(chalk.red("Please update dfx to the version >=0.24.1 or specify pocket-ic version in mops.toml"));
             process.exit(1);
         }
         else {
-            replicaType = 'dfx-pocket-ic';
+            replicaType = "dfx-pocket-ic";
         }
     }
     options.replica = replicaType;
     if (process.env.CI) {
-        console.log('# Benchmark Results\n\n');
+        console.log("# Benchmark Results\n\n");
     }
-    if (replicaType == 'dfx') {
+    if (replicaType == "dfx") {
         options.replicaVersion = getDfxVersion();
     }
-    else if (replicaType == 'pocket-ic') {
-        options.replicaVersion = config.toolchain?.['pocket-ic'] || '';
+    else if (replicaType == "pocket-ic") {
+        options.replicaVersion = config.toolchain?.["pocket-ic"] || "";
     }
     options.verbose && console.log(options);
     let replica = new BenchReplica(replicaType, options.verbose);
     let rootDir = getRootDir();
-    let globStr = '**/bench?(mark)/**/*.bench.mo';
+    let globStr = "**/bench?(mark)/**/*.bench.mo";
     if (filter) {
         globStr = `**/bench?(mark)/**/*${filter}*.mo`;
     }
     let files = globSync(path.join(rootDir, globStr), globConfig);
     if (!files.length) {
         if (filter) {
-            options.silent || console.log(`No benchmark files found for filter '${filter}'`);
+            options.silent ||
+                console.log(`No benchmark files found for filter '${filter}'`);
             return [];
         }
         if (!options.silent) {
-            console.log('No *.bench.mo files found');
-            console.log('Put your benchmark code in \'bench\' directory in *.bench.mo files');
+            console.log("No *.bench.mo files found");
+            console.log("Put your benchmark code in 'bench' directory in *.bench.mo files");
         }
         return [];
     }
@@ -91,26 +93,26 @@ export async function bench(filter = '', optionsArg = {}) {
     fs.rmSync(benchDir, { recursive: true, force: true });
     fs.mkdirSync(benchDir, { recursive: true });
     if (!options.silent && !process.env.CI) {
-        console.log('Benchmark files:');
+        console.log("Benchmark files:");
         for (let file of files) {
             console.log(chalk.gray(`• ${absToRel(file)}`));
         }
         if (!process.env.CI) {
-            console.log('');
-            console.log('='.repeat(50));
-            console.log('');
+            console.log("");
+            console.log("=".repeat(50));
+            console.log("");
         }
     }
     await replica.start({ silent: options.silent });
     if (!process.env.CI && !options.silent) {
-        console.log('Deploying canisters...');
+        console.log("Deploying canisters...");
     }
     await parallel(os.cpus().length, files, async (file) => {
         try {
             await deployBenchFile(file, options, replica);
         }
         catch (err) {
-            console.error('Unexpected error. Stopping replica...');
+            console.error("Unexpected error. Stopping replica...");
             await replica.stop();
             throw err;
         }
@@ -118,22 +120,22 @@ export async function bench(filter = '', optionsArg = {}) {
     let benchResults = [];
     await parallel(1, files, async (file) => {
         if (!options.silent && !process.env.CI) {
-            console.log('\n' + '-'.repeat(50));
+            console.log("\n" + "-".repeat(50));
             console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
-            console.log('');
+            console.log("");
         }
         try {
             let benchResult = await runBenchFile(file, options, replica);
             benchResults.push(benchResult);
         }
         catch (err) {
-            console.error('Unexpected error. Stopping replica...');
+            console.error("Unexpected error. Stopping replica...");
             await replica.stop();
             throw err;
         }
     });
     if (!process.env.CI && !options.silent) {
-        console.log('Stopping replica...');
+        console.log("Stopping replica...");
     }
     await replica.stop();
     fs.rmSync(benchDir, { recursive: true, force: true });
@@ -166,7 +168,12 @@ function computeDiff(results, prevResults, rows, cols, metric) {
     return count > 0 ? diff / count : 0;
 }
 function computeDiffAll(currentResults, prevResults, rows, cols) {
-    let metrics = ['instructions', 'rts_heap_size', 'rts_logical_stable_memory_size', 'rts_reclaimed'];
+    let metrics = [
+        "instructions",
+        "rts_heap_size",
+        "rts_logical_stable_memory_size",
+        "rts_reclaimed",
+    ];
     let diff = 0;
     for (let metric of metrics) {
         diff += computeDiff(currentResults, prevResults, rows, cols, metric);
@@ -174,60 +181,64 @@ function computeDiffAll(currentResults, prevResults, rows, cols) {
     return diff;
 }
 function getMocArgs(options) {
-    let args = '';
-    if (options.compilerVersion && new SemVer(options.compilerVersion).compare('0.15.0') >= 0) {
-        args += ' --legacy-persistence';
+    let args = "";
+    if (options.compilerVersion &&
+        new SemVer(options.compilerVersion).compare("0.15.0") >= 0) {
+        args += " --legacy-persistence";
     }
     if (options.forceGc) {
-        args += ' --force-gc';
+        args += " --force-gc";
     }
     if (options.gc) {
         args += ` --${options.gc}-gc`;
     }
-    if (options.profile === 'Debug') {
-        args += ' --debug';
+    if (options.profile === "Debug") {
+        args += " --debug";
     }
-    else if (options.profile === 'Release') {
-        args += ' --release';
+    else if (options.profile === "Release") {
+        args += " --release";
     }
     return args;
 }
 async function deployBenchFile(file, options, replica) {
     let rootDir = getRootDir();
-    let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
+    let tempDir = path.join(rootDir, ".mops/.bench/", path.parse(file).name);
     let canisterName = path.parse(file).name;
     // prepare temp files
     fs.mkdirSync(tempDir, { recursive: true });
-    fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(replica.dfxJson(canisterName), null, 2));
-    let benchCanisterData = fs.readFileSync(new URL('./bench/bench-canister.mo', import.meta.url), 'utf8');
-    benchCanisterData = benchCanisterData.replace('./user-bench', path.relative(tempDir, file).replace(/.mo$/g, ''));
-    fs.writeFileSync(path.join(tempDir, 'canister.mo'), benchCanisterData);
+    fs.writeFileSync(path.join(tempDir, "dfx.json"), JSON.stringify(replica.dfxJson(canisterName), null, 2));
+    let benchCanisterData = fs.readFileSync(new URL("./bench/bench-canister.mo", import.meta.url), "utf8");
+    benchCanisterData = benchCanisterData.replace("./user-bench", path.relative(tempDir, file).replace(/.mo$/g, ""));
+    fs.writeFileSync(path.join(tempDir, "canister.mo"), benchCanisterData);
     // build canister
     let mocPath = getMocPath();
     let mocArgs = getMocArgs(options);
     options.verbose && console.time(`build ${canisterName}`);
-    await execaCommand(`${mocPath} -c --idl canister.mo ${mocArgs} ${(await sources({ cwd: tempDir })).join(' ')}`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+    await execaCommand(`${mocPath} -c --idl canister.mo ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`, {
+        cwd: tempDir,
+        stdio: options.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
+    });
     options.verbose && console.timeEnd(`build ${canisterName}`);
     // deploy canister
-    let wasm = path.join(tempDir, 'canister.wasm');
+    let wasm = path.join(tempDir, "canister.wasm");
     options.verbose && console.time(`deploy ${canisterName}`);
     // await execaCommand(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, {cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']});
     await replica.deploy(canisterName, wasm, tempDir);
     options.verbose && console.timeEnd(`deploy ${canisterName}`);
     // init bench
     options.verbose && console.time(`init ${canisterName}`);
-    let actor = await replica.getActor(canisterName);
+    let actor = (await replica.getActor(canisterName));
     await actor.init();
     options.verbose && console.timeEnd(`init ${canisterName}`);
 }
 async function runBenchFile(file, options, replica) {
     let rootDir = getRootDir();
     let canisterName = path.parse(file).name;
-    let actor = await replica.getActor(canisterName);
+    let actor = (await replica.getActor(canisterName));
     let schema = await actor.getSchema();
     // load previous results
     let prevResults;
-    let resultsJsonFile = path.join(rootDir, '.bench', `${path.parse(file).name}.json`);
+    let resultsJsonFile = path.join(rootDir, ".bench", `${path.parse(file).name}.json`);
     if (options.compare) {
         if (fs.existsSync(resultsJsonFile)) {
             let prevResultsJson = JSON.parse(fs.readFileSync(resultsJsonFile).toString());
@@ -243,25 +254,25 @@ async function runBenchFile(file, options, replica) {
     let logicalStableMemoryCells = Array.from({ length: schema.rows.length }, () => []);
     let reclaimedCells = Array.from({ length: schema.rows.length }, () => []);
     let formatNumber = (n) => {
-        return n.toLocaleString('en-US').replaceAll(',', '_');
+        return n.toLocaleString("en-US").replaceAll(",", "_");
     };
     let formatSize = (n) => {
-        return filesize(n, { standard: 'iec', round: 2 });
+        return filesize(n, { standard: "iec", round: 2 });
     };
     let colorizePercent = (percent, wrapInParens = false) => {
-        let sign = percent > 0 ? '+' : '';
-        let percentText = percent == 0 ? '0%' : sign + percent.toFixed(2) + '%';
-        let color = percent == 0 ? 'gray' : (percent > 0 ? 'red' : 'green');
-        let parens = wrapInParens ? ['(', ')'] : ['', ''];
+        let sign = percent > 0 ? "+" : "";
+        let percentText = percent == 0 ? "0%" : sign + percent.toFixed(2) + "%";
+        let color = percent == 0 ? "gray" : percent > 0 ? "red" : "green";
+        let parens = wrapInParens ? ["(", ")"] : ["", ""];
         if (process.env.CI) {
-            return `$${parens[0]}{\\color{${color}}${percentText.replace('%', '\\\\%')}}${parens[1]}$`;
+            return `$${parens[0]}{\\color{${color}}${percentText.replace("%", "\\\\%")}}${parens[1]}$`;
         }
         else {
             return `${parens[0]}${chalk[color](percentText)}${parens[1]}`;
         }
     };
     let getTable = (prop) => {
-        let resArr = [['', ...schema.cols]];
+        let resArr = [["", ...schema.cols]];
         let allZero = true;
         for (let [_rowIndex, row] of schema.rows.entries()) {
             let curRow = [row];
@@ -272,26 +283,28 @@ async function runBenchFile(file, options, replica) {
                         allZero = false;
                     }
                     // compare with previous results
-                    let diff = '';
+                    let diff = "";
                     if (options.compare && prevResults) {
                         let prevRes = prevResults.get(`${row}:${col}`);
                         if (prevRes) {
-                            let percent = (Number(res[prop]) - Number(prevRes[prop])) / Number(prevRes[prop]) * 100;
+                            let percent = ((Number(res[prop]) - Number(prevRes[prop])) /
+                                Number(prevRes[prop])) *
+                                100;
                             if (Object.is(percent, NaN)) {
                                 percent = 0;
                             }
-                            diff = ' ' + colorizePercent(percent, true);
+                            diff = " " + colorizePercent(percent, true);
                         }
                         else {
-                            diff = chalk.yellow(' (no previous results)');
+                            diff = chalk.yellow(" (no previous results)");
                         }
                     }
                     // add to table
-                    let value = '';
-                    if (prop == 'rts_logical_stable_memory_size') {
+                    let value = "";
+                    if (prop == "rts_logical_stable_memory_size") {
                         value = formatSize(res[prop] * 65536n);
                     }
-                    else if (prop === 'rts_heap_size' || prop == 'rts_reclaimed') {
+                    else if (prop === "rts_heap_size" || prop == "rts_reclaimed") {
                         value = formatSize(res[prop]);
                     }
                     else {
@@ -300,17 +313,17 @@ async function runBenchFile(file, options, replica) {
                     curRow.push(value + diff);
                 }
                 else {
-                    curRow.push('');
+                    curRow.push("");
                 }
             }
             resArr.push(curRow);
         }
         // don't show Stable Memory table if all values are 0
-        if (allZero && prop == 'rts_logical_stable_memory_size') {
-            return '';
+        if (allZero && prop == "rts_logical_stable_memory_size") {
+            return "";
         }
         return markdownTable(resArr, {
-            align: ['l', ...'r'.repeat(schema.cols.length)],
+            align: ["l", ..."r".repeat(schema.cols.length)],
             stringLength: stringWidth,
         });
     };
@@ -318,39 +331,41 @@ async function runBenchFile(file, options, replica) {
     let getOutput = () => {
         if (process.env.CI) {
             return [
-                '\n<details>',
-                `\n<summary>${absToRel(file)} ${colorizePercent(computeDiffAll(results, prevResults, schema.rows, schema.cols), true).replace('\\\\%', '\\%')}</summary>`,
+                "\n<details>",
+                `\n<summary>${absToRel(file)} ${colorizePercent(computeDiffAll(results, prevResults, schema.rows, schema.cols), true).replace("\\\\%", "\\%")}</summary>`,
                 `\n${process.env.CI ? `### ${schema.name}` : chalk.bold(schema.name)}`,
-                `${schema.description ? '\n' + (process.env.CI ? `_${schema.description}_` : chalk.gray(schema.description)) : ''}`,
-                `\n\nInstructions: ${colorizePercent(computeDiff(results, prevResults, schema.rows, schema.cols, 'instructions'), false)}`,
-                `Heap: ${colorizePercent(computeDiff(results, prevResults, schema.rows, schema.cols, 'rts_heap_size'), false)}`,
-                `Stable Memory: ${colorizePercent(computeDiff(results, prevResults, schema.rows, schema.cols, 'rts_logical_stable_memory_size'), false)}`,
-                `Garbage Collection: ${colorizePercent(computeDiff(results, prevResults, schema.rows, schema.cols, 'rts_reclaimed'), false)}`,
-                `\n\n**Instructions**\n\n${getTable('instructions')}`,
-                `\n\n**Heap**\n\n${getTable('rts_heap_size')}`,
-                `\n\n**Garbage Collection**\n\n${getTable('rts_reclaimed')}`,
-                `${getTable('rts_logical_stable_memory_size') ? `\n\n**Stable Memory**\n\n${getTable('rts_logical_stable_memory_size')}` : ''}`,
-                '\n</details>',
-            ].join('\n');
+                `${schema.description ? "\n" + (process.env.CI ? `_${schema.description}_` : chalk.gray(schema.description)) : ""}`,
+                `\n\nInstructions: ${colorizePercent(computeDiff(results, prevResults, schema.rows, schema.cols, "instructions"), false)}`,
+                `Heap: ${colorizePercent(computeDiff(results, prevResults, schema.rows, schema.cols, "rts_heap_size"), false)}`,
+                `Stable Memory: ${colorizePercent(computeDiff(results, prevResults, schema.rows, schema.cols, "rts_logical_stable_memory_size"), false)}`,
+                `Garbage Collection: ${colorizePercent(computeDiff(results, prevResults, schema.rows, schema.cols, "rts_reclaimed"), false)}`,
+                `\n\n**Instructions**\n\n${getTable("instructions")}`,
+                `\n\n**Heap**\n\n${getTable("rts_heap_size")}`,
+                `\n\n**Garbage Collection**\n\n${getTable("rts_reclaimed")}`,
+                `${getTable("rts_logical_stable_memory_size") ? `\n\n**Stable Memory**\n\n${getTable("rts_logical_stable_memory_size")}` : ""}`,
+                "\n</details>",
+            ].join("\n");
         }
         else {
             return `
 				\n${chalk.bold(schema.name)}
-				${schema.description ? '\n' + chalk.gray(schema.description) : ''}
-				\n\n${chalk.blue('Instructions')}\n\n${getTable('instructions')}
-				\n\n${chalk.blue('Heap')}\n\n${getTable('rts_heap_size')}
-				\n\n${chalk.blue('Garbage Collection')}\n\n${getTable('rts_reclaimed')}
-				${getTable('rts_logical_stable_memory_size') ? `\n\n${chalk.blue('Stable Memory')}\n\n${getTable('rts_logical_stable_memory_size')}` : ''}
+				${schema.description ? "\n" + chalk.gray(schema.description) : ""}
+				\n\n${chalk.blue("Instructions")}\n\n${getTable("instructions")}
+				\n\n${chalk.blue("Heap")}\n\n${getTable("rts_heap_size")}
+				\n\n${chalk.blue("Garbage Collection")}\n\n${getTable("rts_reclaimed")}
+				${getTable("rts_logical_stable_memory_size") ? `\n\n${chalk.blue("Stable Memory")}\n\n${getTable("rts_logical_stable_memory_size")}` : ""}
 			`;
         }
     };
-    let canUpdateLog = !process.env.CI && !options.silent && terminalSize().rows > getOutput().split('\n').length;
+    let canUpdateLog = !process.env.CI &&
+        !options.silent &&
+        terminalSize().rows > getOutput().split("\n").length;
     let log = () => {
         if (options.silent) {
             return;
         }
         let output = getOutput();
-        if (process.env.CI || terminalSize().rows <= output.split('\n').length) {
+        if (process.env.CI || terminalSize().rows <= output.split("\n").length) {
             console.log(output);
         }
         else {
@@ -370,7 +385,8 @@ async function runBenchFile(file, options, replica) {
             // @ts-ignore
             heapCells[rowIndex][colIndex] = res.rts_heap_size;
             // @ts-ignore
-            logicalStableMemoryCells[rowIndex][colIndex] = res.rts_logical_stable_memory_size;
+            logicalStableMemoryCells[rowIndex][colIndex] =
+                res.rts_logical_stable_memory_size;
             // @ts-ignore
             reclaimedCells[rowIndex][colIndex] = res.rts_reclaimed;
             if (canUpdateLog) {
@@ -398,7 +414,7 @@ async function runBenchFile(file, options, replica) {
         };
         fs.mkdirSync(path.dirname(resultsJsonFile), { recursive: true });
         fs.writeFileSync(resultsJsonFile, JSON.stringify(json, (_, val) => {
-            if (typeof val === 'bigint') {
+            if (typeof val === "bigint") {
                 return Number(val);
             }
             else {
@@ -420,10 +436,10 @@ async function runBenchFile(file, options, replica) {
         rows: schema.rows,
         cols: schema.cols,
         metrics: [
-            ['instructions', instructionsCells],
-            ['rts_heap_size', heapCells],
-            ['rts_logical_stable_memory_size', logicalStableMemoryCells],
-            ['rts_reclaimed', reclaimedCells],
+            ["instructions", instructionsCells],
+            ["rts_heap_size", heapCells],
+            ["rts_logical_stable_memory_size", logicalStableMemoryCells],
+            ["rts_reclaimed", reclaimedCells],
         ],
     };
 }

package/dist/commands/build.d.ts

@@ -0,0 +1,7 @@
+export interface BuildOptions {
+    outputDir: string;
+    verbose: boolean;
+    extraArgs: string[];
+}
+export declare const DEFAULT_BUILD_OUTPUT_DIR = ".mops/.build";
+export declare function build(canisterNames: string[] | undefined, options: Partial<BuildOptions>): Promise<void>;

package/dist/commands/build.js

@@ -0,0 +1,121 @@
+import chalk from "chalk";
+import { execa } from "execa";
+import { exists } from "fs-extra";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { getMocPath } from "../helpers/get-moc-path.js";
+import { readConfig } from "../mops.js";
+import { sourcesArgs } from "./sources.js";
+import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
+import { cliError } from "../error.js";
+export const DEFAULT_BUILD_OUTPUT_DIR = ".mops/.build";
+export async function build(canisterNames, options) {
+    if (canisterNames?.length == 0) {
+        cliError("No canisters specified to build");
+    }
+    let outputDir = options.outputDir ?? DEFAULT_BUILD_OUTPUT_DIR;
+    let mocPath = getMocPath();
+    let canisters = {};
+    let config = readConfig();
+    if (config.canisters) {
+        canisters =
+            Object.fromEntries(Object.entries(config.canisters).map(([name, c]) => typeof c === "string" ? [name, { main: c }] : [name, c])) ?? {};
+    }
+    if (!Object.keys(canisters).length) {
+        cliError(`No Motoko canisters found in mops.toml configuration`);
+    }
+    if (canisterNames) {
+        canisterNames = canisterNames.filter((name) => name in canisters);
+        if (canisterNames.length === 0) {
+            throw new Error("No valid canister names specified");
+        }
+        for (let name of canisterNames) {
+            if (!(name in canisters)) {
+                cliError(`Motoko canister '${name}' not found in mops.toml configuration`);
+            }
+        }
+    }
+    if (!(await exists(outputDir))) {
+        await mkdir(outputDir, { recursive: true });
+    }
+    const filteredCanisters = canisterNames
+        ? Object.fromEntries(Object.entries(canisters).filter(([name]) => canisterNames.includes(name)))
+        : canisters;
+    for (let [canisterName, canister] of Object.entries(filteredCanisters)) {
+        options.verbose && console.time(`build canister ${canisterName}`);
+        console.log(chalk.blue("build canister"), chalk.bold(canisterName));
+        let motokoPath = canister.main;
+        if (!motokoPath) {
+            cliError(`No main file is specified for canister ${canisterName}`);
+        }
+        let args = [
+            "-c",
+            "--idl",
+            "-o",
+            join(outputDir, `${canisterName}.wasm`),
+            motokoPath,
+            ...(options.extraArgs ?? []),
+            ...(await sourcesArgs()).flat(),
+        ];
+        if (config.build?.args) {
+            if (typeof config.build.args === "string") {
+                cliError(`[build] config 'args' should be an array of strings in mops.toml config file`);
+            }
+            args.push(...config.build.args);
+        }
+        if (canister.args) {
+            if (typeof canister.args === "string") {
+                cliError(`Canister config 'args' should be an array of strings for canister ${canisterName}`);
+            }
+            args.push(...canister.args);
+        }
+        try {
+            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("Build output:"));
+                        console.error(result.stdout);
+                    }
+                }
+                cliError(`Build failed for canister ${canisterName} (exit code: ${result.exitCode})`);
+            }
+            if (options.verbose && result.stdout && result.stdout.trim()) {
+                console.log(result.stdout);
+            }
+            if (canister.candid) {
+                const generatedDidPath = join(outputDir, `${canisterName}.did`);
+                const originalCandidPath = canister.candid;
+                try {
+                    const compatible = await isCandidCompatible(generatedDidPath, originalCandidPath);
+                    if (!compatible) {
+                        cliError(`Candid compatibility check failed for canister ${canisterName}`);
+                    }
+                    if (options.verbose) {
+                        console.log(chalk.green(`Candid compatibility check passed for canister ${canisterName}`));
+                    }
+                }
+                catch (candidError) {
+                    cliError(`Error during Candid compatibility check for canister ${canisterName}`, candidError);
+                }
+            }
+        }
+        catch (cliError) {
+            if (cliError.message?.includes("Build failed for canister")) {
+                throw cliError;
+            }
+            cliError(`Error while compiling canister ${canisterName}${cliError?.message ? `\n${cliError.message}` : ""}`);
+        }
+        options.verbose && console.timeEnd(`build canister ${canisterName}`);
+    }
+    console.log(chalk.green(`\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length == 1 ? "" : "s"} successfully`));
+}