ic-mops 0.39.2 → 0.40.0

package/.gitignore

@@ -1,5 +1,6 @@
 node_modules
 dist
+bundle
 cli.js
 identity.pem
 network.txt

package/api/actors.ts

@@ -9,7 +9,7 @@ import {_SERVICE as _STORAGE_SERVICE} from '../declarations/storage/storage.did.
 import {getEndpoint} from './network.js';
 import {getNetwork} from './network.js';
 
-export let mainActor = async (identity?: Identity): Promise<_SERVICE> => {
+export let mainActor = async (identity ?: Identity) : Promise<_SERVICE> => {
 	let network = getNetwork();
 	let host = getEndpoint(network).host;
 	let canisterId = getEndpoint(network).canisterId;
@@ -27,7 +27,7 @@ export let mainActor = async (identity?: Identity): Promise<_SERVICE> => {
 	});
 };
 
-export let storageActor = async (storageId: Principal, identity?: Identity): Promise<_STORAGE_SERVICE> => {
+export let storageActor = async (storageId : Principal, identity ?: Identity) : Promise<_STORAGE_SERVICE> => {
 	let network = getNetwork();
 	let host = getEndpoint(network).host;
 

package/api/downloadPackageFiles.ts

@@ -4,14 +4,14 @@ import {resolveVersion} from './resolveVersion.js';
 import {parallel} from '../parallel.js';
 import {Storage} from '../declarations/storage/storage.did.js';
 
-export async function downloadPackageFiles(pkg: string, version = '', threads = 8, onLoad = (_fileIds: string[], _fileId: string) => {}): Promise<Map<string, Array<number>>> {
+export async function downloadPackageFiles(pkg : string, version = '', threads = 8, onLoad = (_fileIds : string[], _fileId : string) => {}) : Promise<Map<string, Array<number>>> {
 	version = await resolveVersion(pkg, version);
 
 	let {storageId, fileIds} = await getPackageFilesInfo(pkg, version);
 	let storage = await storageActor(storageId);
 
 	let filesData = new Map<string, Array<number>>();
-	await parallel(threads, fileIds, async (fileId: string) => {
+	await parallel(threads, fileIds, async (fileId : string) => {
 		let {path, data} = await downloadFile(storage, fileId);
 		filesData.set(path, data);
 		onLoad(fileIds, fileId);
@@ -21,7 +21,7 @@ export async function downloadPackageFiles(pkg: string, version = '', threads =
 }
 
 // get package files meta
-export async function getPackageFilesInfo(pkg: string, version: string): Promise<{ storageId: Principal, fileIds: string[] }> {
+export async function getPackageFilesInfo(pkg : string, version : string) : Promise<{ storageId : Principal, fileIds : string[] }> {
 	let actor = await mainActor();
 
 	let [packageDetailsRes, fileIds] = await Promise.all([
@@ -41,7 +41,7 @@ export async function getPackageFilesInfo(pkg: string, version: string): Promise
 }
 
 // get package files ids
-export async function getFileIds(pkg: string, version: string): Promise<string[]> {
+export async function getFileIds(pkg : string, version : string) : Promise<string[]> {
 	let actor = await mainActor();
 	let fileIdsRes = await actor.getFileIds(pkg, version);
 
@@ -54,14 +54,17 @@ export async function getFileIds(pkg: string, version: string): Promise<string[]
 }
 
 // download single file
-export async function downloadFile(storage: Storage, fileId: string): Promise<{ path: string, data: Array<number> }> {
+export async function downloadFile(storage : Storage | string, fileId : string) : Promise<{path : string, data : Array<number>;}> {
+	if (typeof storage === 'string') {
+		storage = await storageActor(Principal.fromText(storage));
+	}
 	let fileMetaRes = await storage.getFileMeta(fileId);
 	if ('err' in fileMetaRes) {
 		throw fileMetaRes.err;
 	}
 	let fileMeta = fileMetaRes.ok;
 
-	let data: Array<number> = [];
+	let data : Array<number> = [];
 	for (let i = 0n; i < fileMeta.chunkCount; i++) {
 		let chunkRes = await storage.downloadChunk(fileId, i);
 		if ('err' in chunkRes) {

package/api/getHighestVersion.ts

@@ -1,6 +1,6 @@
 import {mainActor} from './actors.js';
 
-export async function getHighestVersion(pkgName: string) {
+export async function getHighestVersion(pkgName : string) {
 	let actor = await mainActor();
 	return actor.getHighestVersion(pkgName);
 }

package/api/network.ts

@@ -2,7 +2,7 @@ export function getNetwork() {
 	return globalThis.MOPS_NETWORK || 'ic';
 }
 
-export function getEndpoint(network: string) {
+export function getEndpoint(network : string) {
 	if (network === 'staging') {
 		return {
 			host: 'https://icp-api.io',

package/api/resolveVersion.ts

@@ -1,6 +1,6 @@
 import {getHighestVersion} from './getHighestVersion.js';
 
-export async function resolveVersion(pkg: string, version = ''): Promise<string> {
+export async function resolveVersion(pkg : string, version = '') : Promise<string> {
 	if (!version) {
 		let versionRes = await getHighestVersion(pkg);
 		if ('err' in versionRes) {

package/cache.ts

@@ -5,12 +5,12 @@ import getFolderSize from 'get-folder-size';
 
 import {globalCacheDir} from './mops.js';
 
-export let isCached = (pkgId: string) => {
+export let isCached = (pkgId : string) => {
 	let dir = path.join(globalCacheDir, 'packages', pkgId);
 	return fs.existsSync(dir);
 };
 
-export let addCache = (pkgId: string, source: string) => {
+export let addCache = (pkgId : string, source : string) => {
 	let dest = path.join(globalCacheDir, 'packages', pkgId);
 	fs.mkdirSync(dest, {recursive: true});
 
@@ -24,7 +24,7 @@ export let addCache = (pkgId: string, source: string) => {
 	});
 };
 
-export let copyCache = (pkgId: string, dest: string) => {
+export let copyCache = (pkgId : string, dest : string) => {
 	let source = path.join(globalCacheDir, 'packages', pkgId);
 	fs.mkdirSync(dest, {recursive: true});
 

package/cli.ts

@@ -30,7 +30,7 @@ import {Tool} from './types.js';
 
 declare global {
 	// eslint-disable-next-line no-var
-	var MOPS_NETWORK: string;
+	var MOPS_NETWORK : string;
 }
 
 let networkFile = getNetworkFile();
@@ -121,6 +121,7 @@ program
 	.description('Publish package to the mops registry')
 	.option('--no-docs', 'Do not generate docs')
 	.option('--no-test', 'Do not run tests')
+	.option('--no-bench', 'Do not run benchmarks')
 	.action(async (options) => {
 		if (!checkConfigFile()) {
 			process.exit(1);
@@ -366,7 +367,7 @@ toolchainCommand
 	.command('update')
 	.description('Update specified tool or all tools to the latest version and update mops.toml')
 	.addArgument(new Argument('[tool]').choices(['moc', 'wasmtime', 'pocket-ic']))
-	.action(async (tool?: Tool) => {
+	.action(async (tool ?: Tool) => {
 		if (!checkConfigFile()) {
 			process.exit(1);
 		}

package/commands/add.ts

@@ -9,13 +9,13 @@ import {notifyInstalls} from '../notify-installs.js';
 import {checkIntegrity} from '../integrity.js';
 
 type AddOptions = {
-	verbose?: boolean;
-	dev?: boolean;
-	lock?: 'update' | 'ignore';
+	verbose ?: boolean;
+	dev ?: boolean;
+	lock ?: 'update' | 'ignore';
 };
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function add(name: string, {verbose = false, dev = false, lock}: AddOptions = {}, asName?: string) {
+export async function add(name : string, {verbose = false, dev = false, lock} : AddOptions = {}, asName ?: string) {
 	if (!checkConfigFile()) {
 		return;
 	}
@@ -32,7 +32,7 @@ export async function add(name: string, {verbose = false, dev = false, lock}: Ad
 		}
 	}
 
-	let pkgDetails: any;
+	let pkgDetails : any;
 
 	// local package
 	if (name.startsWith('./') || name.startsWith('../') || name.startsWith('/')) {
@@ -64,7 +64,7 @@ export async function add(name: string, {verbose = false, dev = false, lock}: Ad
 	}
 	// mops package
 	else {
-		let ver: string;
+		let ver : string;
 		if (name.includes('@')) {
 			// @ts-ignore
 			[name, ver] = name.split('@');

package/commands/available-updates.ts

@@ -3,13 +3,13 @@ import {mainActor} from '../api/actors.js';
 import {Config} from '../types.js';
 
 // [pkg, oldVersion, newVersion]
-export async function getAvailableUpdates(config: Config, pkg?: string): Promise<Array<[string, string, string]>> {
+export async function getAvailableUpdates(config : Config, pkg ?: string) : Promise<Array<[string, string, string]>> {
 	let deps = Object.values(config.dependencies || {});
 	let devDeps = Object.values(config['dev-dependencies'] || {});
 	let allDeps = [...deps, ...devDeps].filter((dep) => dep.version);
 	let depsToUpdate = pkg ? allDeps.filter((dep) => dep.name === pkg) : allDeps;
 
-	let getCurrentVersion = (pkg: string) => {
+	let getCurrentVersion = (pkg : string) => {
 		for (let dep of allDeps) {
 			if (dep.name === pkg && dep.version) {
 				return dep.version;

package/commands/bench-replica.ts

@@ -10,16 +10,16 @@ import {toolchain} from './toolchain/index.js';
 export class BenchReplica {
 	type : 'dfx' | 'pocket-ic';
 	verbose = false;
-	canisters: Record<string, {cwd: string; canisterId: string; actor: any;}> = {};
-	pocketIc?: PocketIc;
+	canisters : Record<string, {cwd : string; canisterId : string; actor : any;}> = {};
+	pocketIc ?: PocketIc;
 
-	constructor(type: 'dfx' | 'pocket-ic', verbose = false) {
+	constructor(type : 'dfx' | 'pocket-ic', verbose = false) {
 		this.type = type;
 		this.verbose = verbose;
 	}
 
-	async start() {
-		console.log(`Starting ${this.type} replica...`);
+	async start({silent = false} = {}) {
+		silent || console.log(`Starting ${this.type} replica...`);
 
 		if (this.type == 'dfx') {
 			await this.stop();
@@ -48,7 +48,7 @@ export class BenchReplica {
 		}
 	}
 
-	async deploy(name: string, wasm: string, cwd: string = process.cwd()) {
+	async deploy(name : string, wasm : string, cwd : string = process.cwd()) {
 		if (this.type === 'dfx') {
 			await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, {cwd, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']});
 			let canisterId = execSync(`dfx canister id ${name}`, {cwd}).toString().trim();
@@ -69,16 +69,16 @@ export class BenchReplica {
 		}
 	}
 
-	getActor(name: string): unknown {
+	getActor(name : string) : unknown {
 		return this.canisters[name]?.actor;
 	}
 
-	getCanisterId(name: string): string {
+	getCanisterId(name : string) : string {
 		return this.canisters[name]?.canisterId || '';
 	}
 
-	dfxJson(canisterName: string) {
-		let canisters: Record<string, any> = {};
+	dfxJson(canisterName : string) {
+		let canisters : Record<string, any> = {};
 		if (canisterName) {
 			canisters[canisterName] = {
 				type: 'custom',

package/commands/bench.ts

@@ -8,7 +8,7 @@ import logUpdate from 'log-update';
 import {execaCommand} from 'execa';
 import stringWidth from 'string-width';
 
-import {getRootDir} from '../mops.js';
+import {getRootDir, readConfig} from '../mops.js';
 import {parallel} from '../parallel.js';
 import {absToRel} from './test/utils.js';
 import {getMocVersion} from '../helpers/get-moc-version.js';
@@ -16,7 +16,8 @@ import {getDfxVersion} from '../helpers/get-dfx-version.js';
 import {getMocPath} from '../helpers/get-moc-path.js';
 import {sources} from './sources.js';
 
-import {BenchResult, BenchSchema, _SERVICE} from '../declarations/bench/bench.did.js';
+import {Benchmark, Benchmarks} from '../declarations/main/main.did.js';
+import {BenchResult, _SERVICE} from '../declarations/bench/bench.did.js';
 import {BenchReplica} from './bench-replica.js';
 
 let ignore = [
@@ -32,31 +33,42 @@ let globConfig = {
 };
 
 type BenchOptions = {
-	replica: 'dfx' | 'pocket-ic',
-	replicaVersion: string,
-	moc: string,
-	gc: 'copying' | 'compacting' | 'generational' | 'incremental',
-	forceGc: boolean,
-	save: boolean,
-	compare: boolean,
-	verbose: boolean,
+	replica : 'dfx' | 'pocket-ic',
+	replicaVersion : string,
+	compiler : 'moc',
+	compilerVersion : string,
+	gc : 'copying' | 'compacting' | 'generational' | 'incremental',
+	forceGc : boolean,
+	save : boolean,
+	compare : boolean,
+	verbose : boolean,
+	silent : boolean,
+
 };
 
-export async function bench(filter = '', optionsArg: Partial<BenchOptions> = {}): Promise<boolean> {
-	let defaultOptions: BenchOptions = {
+export async function bench(filter = '', optionsArg : Partial<BenchOptions> = {}) : Promise<Benchmarks> {
+	let defaultOptions : BenchOptions = {
 		replica: 'dfx',
-		moc: getMocVersion(),
-		replicaVersion: '0.0.0',
+		replicaVersion: '',
+		compiler: 'moc',
+		compilerVersion: getMocVersion(),
 		gc: 'copying',
 		forceGc: true,
 		save: false,
 		compare: false,
 		verbose: false,
+		silent: false,
 	};
 
-	let options: BenchOptions = {...defaultOptions, ...optionsArg};
+	let options : BenchOptions = {...defaultOptions, ...optionsArg};
 
-	options.replicaVersion = options.replica == 'dfx' ? getDfxVersion() : '1.0.0';
+	if (options.replica == 'dfx') {
+		options.replicaVersion = getDfxVersion();
+	}
+	else if (options.replica == 'pocket-ic') {
+		let config = readConfig();
+		options.replicaVersion = config.toolchain?.['pocket-ic'] || '';
+	}
 
 	options.verbose && console.log(options);
 
@@ -70,12 +82,14 @@ export async function bench(filter = '', optionsArg: Partial<BenchOptions> = {})
 	let files = globSync(path.join(rootDir, globStr), globConfig);
 	if (!files.length) {
 		if (filter) {
-			console.log(`No benchmark files found for filter '${filter}'`);
-			return false;
+			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 false;
+		return [];
 	}
 
 	files.sort();
@@ -84,18 +98,20 @@ export async function bench(filter = '', optionsArg: Partial<BenchOptions> = {})
 	fs.rmSync(benchDir, {recursive: true, force: true});
 	fs.mkdirSync(benchDir, {recursive: true});
 
-	console.log('Benchmark files:');
-	for (let file of files) {
-		console.log(chalk.gray(`• ${absToRel(file)}`));
+	if (!options.silent) {
+		console.log('Benchmark files:');
+		for (let file of files) {
+			console.log(chalk.gray(`• ${absToRel(file)}`));
+		}
+		console.log('');
+		console.log('='.repeat(50));
+		console.log('');
 	}
-	console.log('');
-	console.log('='.repeat(50));
-	console.log('');
 
-	await replica.start();
+	await replica.start({silent: options.silent});
 
-	console.log('Deploying canisters...');
-	await parallel(os.cpus().length, files, async (file: string) => {
+	options.silent || console.log('Deploying canisters...');
+	await parallel(os.cpus().length, files, async (file : string) => {
 		try {
 			await deployBenchFile(file, options, replica);
 		}
@@ -106,12 +122,17 @@ export async function bench(filter = '', optionsArg: Partial<BenchOptions> = {})
 		}
 	});
 
-	await parallel(1, files, async (file: string) => {
-		console.log('\n' + '—'.repeat(50));
-		console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
-		console.log('');
+	let benchResults : Benchmarks = [];
+
+	await parallel(1, files, async (file : string) => {
+		if (!options.silent) {
+			console.log('\n' + '—'.repeat(50));
+			console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
+			console.log('');
+		}
 		try {
-			await runBenchFile(file, options, replica);
+			let benchResult = await runBenchFile(file, options, replica);
+			benchResults.push(benchResult);
 		}
 		catch (err) {
 			console.error('Unexpected error. Stopping replica...');
@@ -120,15 +141,15 @@ export async function bench(filter = '', optionsArg: Partial<BenchOptions> = {})
 		}
 	});
 
-	console.log('Stopping replica...');
+	options.silent || console.log('Stopping replica...');
 	await replica.stop();
 
 	fs.rmSync(benchDir, {recursive: true, force: true});
 
-	return true;
+	return benchResults;
 }
 
-function getMocArgs(options: BenchOptions): string {
+function getMocArgs(options : BenchOptions) : string {
 	let args = '';
 	if (options.forceGc) {
 		args += ' --force-gc';
@@ -139,7 +160,7 @@ function getMocArgs(options: BenchOptions): string {
 	return args;
 }
 
-async function deployBenchFile(file: string, options: BenchOptions, replica: BenchReplica): Promise<void> {
+async function deployBenchFile(file : string, options : BenchOptions, replica : BenchReplica) : Promise<void> {
 	let rootDir = getRootDir();
 	let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
 	let canisterName = path.parse(file).name;
@@ -173,12 +194,7 @@ async function deployBenchFile(file: string, options: BenchOptions, replica: Ben
 	options.verbose && console.timeEnd(`init ${canisterName}`);
 }
 
-type RunBenchFileResult = {
-	schema: BenchSchema,
-	results: Map<string, BenchResult>,
-};
-
-async function runBenchFile(file: string, options: BenchOptions, replica: BenchReplica): Promise<RunBenchFileResult> {
+async function runBenchFile(file : string, options : BenchOptions, replica : BenchReplica) : Promise<Benchmark> {
 	let rootDir = getRootDir();
 	let canisterName = path.parse(file).name;
 
@@ -186,7 +202,7 @@ async function runBenchFile(file: string, options: BenchOptions, replica: BenchR
 	let schema = await actor.getSchema();
 
 	// load previous results
-	let prevResults: Map<string, BenchResult> | undefined;
+	let prevResults : Map<string, BenchResult> | undefined;
 	let resultsJsonFile = path.join(rootDir, '.bench', `${path.parse(file).name}.json`);
 	if (options.compare) {
 		if (fs.existsSync(resultsJsonFile)) {
@@ -200,11 +216,14 @@ async function runBenchFile(file: string, options: BenchOptions, replica: BenchR
 
 	let results = new Map<string, BenchResult>();
 
-	let formatNumber = (n: bigint | number): string => {
+	let instructionsCells : bigint[][] = Array.from({length: schema.rows.length}, () => []);
+	let heapCells : bigint[][] = Array.from({length: schema.rows.length}, () => []);
+
+	let formatNumber = (n : bigint | number) : string => {
 		return n.toLocaleString('en-US').replaceAll(',', '_');
 	};
 
-	let getTable = (prop: keyof BenchResult): string => {
+	let getTable = (prop : keyof BenchResult) : string => {
 		let resArr = [['', ...schema.cols]];
 
 		for (let [_rowIndex, row] of schema.rows.entries()) {
@@ -222,7 +241,7 @@ async function runBenchFile(file: string, options: BenchOptions, replica: BenchR
 							let percent = (Number(res[prop]) - Number(prevRes[prop])) / Number(prevRes[prop]) * 100;
 							let sign = percent > 0 ? '+' : '';
 							let percentText = percent == 0 ? '0%' : sign + percent.toFixed(2) + '%';
-							let color: keyof typeof chalk = percent == 0 ? 'gray' : (percent > 0 ? 'red' : 'green');
+							let color : keyof typeof chalk = percent == 0 ? 'gray' : (percent > 0 ? 'red' : 'green');
 							diff = ` (${chalk[color](percentText)})`;
 						}
 						else {
@@ -255,18 +274,22 @@ async function runBenchFile(file: string, options: BenchOptions, replica: BenchR
 		`);
 	};
 
-	if (!process.env.CI) {
+	if (!process.env.CI && !options.silent) {
 		printResults();
 	}
 
 	// run all cells
 	for (let [rowIndex, row] of schema.rows.entries()) {
 		for (let [colIndex, col] of schema.cols.entries()) {
-			// let res = await actor.runCellQuery(BigInt(rowIndex), BigInt(colIndex));
-			// let res = await actor.runCellUpdate(BigInt(rowIndex), BigInt(colIndex));
 			let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
 			results.set(`${row}:${col}`, res);
-			if (!process.env.CI) {
+
+			// @ts-ignore
+			instructionsCells[rowIndex][colIndex] = res.instructions;
+			// @ts-ignore
+			heapCells[rowIndex][colIndex] = res.rts_heap_size;
+
+			if (!process.env.CI && !options.silent) {
 				printResults();
 			}
 		}
@@ -280,9 +303,9 @@ async function runBenchFile(file: string, options: BenchOptions, replica: BenchR
 	// save results
 	if (options.save) {
 		console.log(`Saving results to ${chalk.gray(absToRel(resultsJsonFile))}`);
-		let json: Record<any, any> = {
+		let json : Record<any, any> = {
 			version: 1,
-			moc: options.moc,
+			moc: options.compilerVersion,
 			replica: options.replica,
 			replicaVersion: options.replicaVersion,
 			gc: options.gc,
@@ -300,5 +323,22 @@ async function runBenchFile(file: string, options: BenchOptions, replica: BenchR
 		}, 2));
 	}
 
-	return {schema, results};
+	// for backend
+	return {
+		name: schema.name,
+		description: schema.description,
+		file: absToRel(file),
+		gc: options.gc,
+		forceGC: options.forceGc,
+		replica: options.replica,
+		replicaVersion: options.replicaVersion,
+		compiler: options.compiler,
+		compilerVersion: options.compilerVersion,
+		rows: schema.rows,
+		cols: schema.cols,
+		metrics: [
+			['instructions', instructionsCells],
+			['rts_heap_size', heapCells],
+		],
+	};
 }

package/commands/bump.ts

@@ -2,7 +2,7 @@ import prompts from 'prompts';
 import chalk from 'chalk';
 import {checkConfigFile, readConfig, writeConfig} from '../mops.js';
 
-export async function bump(part: string) {
+export async function bump(part : string) {
 	if (!checkConfigFile()) {
 		return;
 	}
@@ -44,7 +44,7 @@ export async function bump(part: string) {
 	console.log(`Updated version: ${chalk.green.bold(config.package.version)}`);
 }
 
-function updateVersion(version: string, part: string) {
+function updateVersion(version : string, part : string) {
 	let parts = version.split('.');
 	let idx = ['major', 'minor', 'patch'].indexOf(part);
 	if (!parts[idx]) {

package/commands/docs.ts

@@ -10,7 +10,7 @@ import streamToPromise from 'stream-to-promise';
 import {getRootDir} from '../mops.js';
 import {toolchain} from './toolchain/index.js';
 
-let moDocPath: string;
+let moDocPath : string;
 
 export async function docs({silent = false} = {}) {
 	let rootDir = getRootDir();

package/commands/import-identity.ts

@@ -7,10 +7,10 @@ import {globalConfigDir} from '../mops.js';
 import {encrypt} from '../pem.js';
 
 type ImportIdentityOptions = {
-	encrypt: boolean;
+	encrypt : boolean;
 };
 
-export async function importPem(data: string, options: ImportIdentityOptions = {encrypt: true}) {
+export async function importPem(data : string, options : ImportIdentityOptions = {encrypt: true}) {
 	try {
 		if (!fs.existsSync(globalConfigDir)) {
 			fs.mkdirSync(globalConfigDir);

package/commands/init.ts

@@ -21,7 +21,7 @@ export async function init({yes = false} = {}) {
 
 	console.log('Initializing...');
 
-	let config: Config = {};
+	let config : Config = {};
 
 	if (yes) {
 		await applyInit({
@@ -36,7 +36,7 @@ export async function init({yes = false} = {}) {
 
 	// migrate from vessel
 	let vesselFile = path.join(process.cwd(), 'vessel.dhall');
-	let vesselConfig: VesselConfig = {dependencies: [], 'dev-dependencies': []};
+	let vesselConfig : VesselConfig = {dependencies: [], 'dev-dependencies': []};
 
 	if (existsSync(vesselFile)) {
 		console.log('Reading vessel.dhall file');
@@ -47,7 +47,7 @@ export async function init({yes = false} = {}) {
 	}
 
 	if (vesselConfig.dependencies) {
-		let deps: Dependencies = {};
+		let deps : Dependencies = {};
 		deps = {};
 
 		for (const dep of (vesselConfig.dependencies || [])) {
@@ -63,7 +63,7 @@ export async function init({yes = false} = {}) {
 		onCancel() {
 			console.log('aborted');
 			process.exit(0);
-		}
+		},
 	};
 
 	// type
@@ -162,11 +162,11 @@ export async function init({yes = false} = {}) {
 }
 
 type ApplyInitOptions = {
-	type: 'project' | 'package';
-	config: Config;
-	setupWorkflow: boolean;
-	addTest: boolean;
-	copyrightOwner: string;
+	type : 'project' | 'package';
+	config : Config;
+	setupWorkflow : boolean;
+	addTest : boolean;
+	copyrightOwner : string;
 }
 
 async function applyInit({type, config, setupWorkflow, addTest, copyrightOwner} : ApplyInitOptions) {