ic-mops 0.31.2 → 0.32.1

package/cli.ts

@@ -24,6 +24,7 @@ import {bump} from './commands/bump.js';
 import {sync} from './commands/sync.js';
 import {outdated} from './commands/outdated.js';
 import {update} from './commands/update.js';
+import {bench} from './commands/bench.js';
 import {transferOwnership} from './commands/transfer-ownership.js';
 // import {docs} from './commands/docs.js';
 
@@ -198,6 +199,19 @@ program
 		await test(filter, options);
 	});
 
+// bench
+program
+	.command('bench [filter]')
+	.description('Run benchmarks')
+	.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('--gc <gc>', 'Garbage collector').choices(['copying', 'compacting', 'generational', 'incremental']).default('incremental'))
+	// .addOption(new Option('--force-gc', 'Force GC'))
+	.addOption(new Option('--verbose', 'Show more information'))
+	.action(async (filter, options) => {
+		await bench(filter, options);
+	});
+
 // template
 program
 	.command('template')

package/commands/bench/bench-canister.mo

@@ -0,0 +1,87 @@
+import Nat64 "mo:base/Nat64";
+import Nat "mo:base/Nat";
+import Debug "mo:base/Debug";
+import ExperimentalInternetComputer "mo:base/ExperimentalInternetComputer";
+import Prim "mo:prim";
+import Bench "mo:bench";
+
+import UserBench "./user-bench"; // file path will be replaced with the *.bench.mo file path
+
+actor class() {
+	var benchOpt : ?Bench.Bench = null;
+
+	public func init() : async Bench.BenchSchema {
+		let bench = UserBench.init();
+		benchOpt := ?bench;
+		bench.getSchema();
+	};
+
+	public query func getSchema() : async Bench.BenchSchema {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+		bench.getSchema();
+	};
+
+	func _getStats() : Bench.BenchResult {
+		{
+			instructions = 0;
+			rts_heap_size = Prim.rts_heap_size();
+			rts_memory_size = Prim.rts_memory_size();
+			rts_total_allocation = Prim.rts_total_allocation();
+			rts_mutator_instructions = Prim.rts_mutator_instructions();
+			rts_collector_instructions = Prim.rts_collector_instructions();
+		}
+	};
+
+	func _diffStats(before : Bench.BenchResult, after : Bench.BenchResult) : Bench.BenchResult {
+		{
+			instructions = after.instructions - before.instructions;
+			rts_heap_size = after.rts_heap_size - before.rts_heap_size;
+			rts_memory_size = after.rts_memory_size - before.rts_memory_size;
+			rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
+			rts_mutator_instructions = after.rts_mutator_instructions - before.rts_mutator_instructions;
+			rts_collector_instructions = after.rts_collector_instructions - before.rts_collector_instructions;
+		}
+	};
+
+	func _runCell(rowIndex : Nat, colIndex : Nat) : Bench.BenchResult {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+		let statsBefore = _getStats();
+
+		let instructions = Nat64.toNat(ExperimentalInternetComputer.countInstructions(func() {
+			bench.runCell(rowIndex, colIndex);
+		}));
+
+		let statsAfter = _getStats();
+		_diffStats(statsBefore, { statsAfter with instructions });
+	};
+
+	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+		let statsBefore = _getStats();
+
+		let instructions = Nat64.toNat(ExperimentalInternetComputer.countInstructions(func() {
+			bench.runCell(rowIndex, colIndex);
+		}));
+
+		await (func() : async () {})();
+
+		let statsAfter = _getStats();
+		_diffStats(statsBefore, { statsAfter with instructions });
+	};
+
+	public query func getStats() : async Bench.BenchResult {
+		_getStats();
+	};
+
+	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		_runCell(rowIndex, colIndex);
+	};
+
+	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		_runCell(rowIndex, colIndex);
+	};
+
+	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		await _runCellAwait(rowIndex, colIndex);
+	};
+};

package/commands/bench/user-bench.mo

@@ -0,0 +1,14 @@
+import Nat "mo:base/Nat";
+import Iter "mo:base/Iter";
+import Buffer "mo:base/Buffer";
+import Vector "mo:vector/Class";
+import Bench "mo:bench";
+
+// placeholder file that will be replaced with the *.bench.mo file
+module {
+	public func init() : Bench.Bench {
+		let bench = Bench.Bench();
+		// benchmark code goes here...
+		bench;
+	};
+};

package/commands/bench.ts

@@ -0,0 +1,337 @@
+import {execSync} from 'node:child_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 logUpdate from 'log-update';
+
+import {getRootDir} from '../mops.js';
+import {parallel} from '../parallel.js';
+import {createActor} from '../declarations/bench/index.js';
+import {BenchResult, BenchSchema, _SERVICE} from '../declarations/bench/bench.did.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 {execaCommand} from 'execa';
+
+let ignore = [
+	'**/node_modules/**',
+	'**/.mops/**',
+	'**/.vessel/**',
+	'**/.git/**',
+];
+
+let globConfig = {
+	nocase: true,
+	ignore: ignore,
+};
+
+type BenchOptions = {
+	dfx?: string,
+	moc?: string,
+	gc?: 'copying' | 'compacting' | 'generational' | 'incremental',
+	forceGc?: boolean,
+	save?: boolean,
+	compare?: boolean,
+	verbose?: boolean,
+};
+
+export async function bench(filter = '', options: BenchOptions = {}): Promise<boolean> {
+	let defaultOptions: BenchOptions = {
+		moc: getMocVersion(),
+		dfx: getDfxVersion(),
+		gc: 'incremental',
+		forceGc: true,
+		save: false,
+		compare: false,
+		verbose: false,
+	};
+
+	options = {...defaultOptions, ...options};
+
+	options.verbose && console.log(options);
+
+	let rootDir = getRootDir();
+	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) {
+			console.log(`No benchmark files found for filter '${filter}'`);
+			return false;
+		}
+		console.log('No *.bench.mo files found');
+		console.log('Put your benchmark code in \'bench\' directory in *.bench.mo files');
+		return false;
+	}
+
+	files.sort();
+
+	let benchDir = `${getRootDir()}/.mops/.bench/`;
+	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)}`));
+	}
+	console.log('');
+	console.log('='.repeat(50));
+	console.log('');
+
+	console.log('Starting dfx replica...');
+	startDfx(options.verbose);
+
+	console.log('Deploying canisters...');
+	await parallel(os.cpus().length, files, async (file: string) => {
+		try {
+			await deployBenchFile(file, options);
+		}
+		catch (err) {
+			console.error('Unexpected error. Stopping dfx replica...');
+			stopDfx(options.verbose);
+			throw err;
+		}
+	});
+
+	await parallel(1, files, async (file: string) => {
+		console.log('\n' + '—'.repeat(50));
+		console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
+		console.log('');
+		try {
+			await runBenchFile(file, options);
+		}
+		catch (err) {
+			console.error('Unexpected error. Stopping dfx replica...');
+			stopDfx(options.verbose);
+			throw err;
+		}
+	});
+
+	console.log('Stopping dfx replica...');
+	stopDfx(options.verbose);
+
+	fs.rmSync(benchDir, {recursive: true, force: true});
+
+	return true;
+}
+
+function getMocArgs(options: BenchOptions): string {
+	let args = '';
+	if (options.forceGc) {
+		args += ' --force-gc';
+	}
+	if (options.gc) {
+		args += ` --${options.gc}-gc`;
+	}
+	return args;
+}
+
+function dfxJson(canisterName: string, options: BenchOptions = {}) {
+	options || console.log(options);
+
+	let canisters: Record<string, any> = {};
+	if (canisterName) {
+		canisters[canisterName] = {
+			type: 'custom',
+			wasm: 'canister.wasm',
+			candid: 'canister.did',
+		};
+	}
+
+	return {
+		version: 1,
+		canisters,
+		defaults: {
+			build: {
+				packtool: 'mops sources',
+			},
+		},
+		networks: {
+			local: {
+				type: 'ephemeral',
+				bind: '127.0.0.1:4944',
+			},
+		},
+	};
+}
+
+function startDfx(verbose = false) {
+	stopDfx(verbose);
+	let dir = path.join(getRootDir(), '.mops/.bench');
+	fs.writeFileSync(path.join(dir, 'dfx.json'), JSON.stringify(dfxJson(''), null, 2));
+	execSync('dfx start --background --clean' + (verbose ? '' : ' -qqqq'), {cwd: dir, stdio: ['inherit', verbose ? 'inherit' : 'ignore', 'inherit']});
+}
+
+function stopDfx(verbose = false) {
+	let dir = path.join(getRootDir(), '.mops/.bench');
+	execSync('dfx stop' + (verbose ? '' : ' -qqqq'), {cwd: dir, stdio: ['pipe', verbose ? 'inherit' : 'ignore', 'pipe']});
+}
+
+async function deployBenchFile(file: string, options: BenchOptions = {}): Promise<void> {
+	let rootDir = getRootDir();
+	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(dfxJson(canisterName, options), 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']});
+	options.verbose && console.timeEnd(`build ${canisterName}`);
+
+	// deploy canister
+	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']});
+	options.verbose && console.timeEnd(`deploy ${canisterName}`);
+
+	// init bench
+	options.verbose && console.time(`init ${canisterName}`);
+	let canisterId = execSync(`dfx canister id ${canisterName}`, {cwd: tempDir}).toString().trim();
+	let actor: _SERVICE = await createActor(canisterId, {
+		agentOptions: {
+			host: 'http://127.0.0.1:4944',
+		},
+	});
+	await actor.init();
+	options.verbose && console.timeEnd(`init ${canisterName}`);
+}
+
+type RunBenchFileResult = {
+	schema: BenchSchema,
+	results: Map<string, BenchResult>,
+};
+
+async function runBenchFile(file: string, options: BenchOptions = {}): Promise<RunBenchFileResult> {
+	let rootDir = getRootDir();
+	let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
+	let canisterName = path.parse(file).name;
+
+	let canisterId = execSync(`dfx canister id ${canisterName}`, {cwd: tempDir}).toString().trim();
+	let actor: _SERVICE = await createActor(canisterId, {
+		agentOptions: {
+			host: 'http://127.0.0.1:4944',
+		},
+	});
+
+	let schema = await actor.getSchema();
+
+	// load previous results
+	let prevResults: Map<string, BenchResult> | undefined;
+	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());
+			prevResults = new Map(prevResultsJson.results);
+		}
+		else {
+			console.log(chalk.yellow(`No previous results found "${resultsJsonFile}"`));
+		}
+	}
+
+	let results = new Map<string, BenchResult>();
+
+	let formatNumber = (n: bigint | number): string => {
+		return n.toLocaleString('en-US').replaceAll(',', '_');
+	};
+
+	let getTable = (prop: keyof BenchResult): string => {
+		let resArr = [['', ...schema.cols]];
+
+		for (let [_rowIndex, row] of schema.rows.entries()) {
+			let curRow = [row];
+
+			for (let [_colIndex, col] of schema.cols.entries()) {
+				let res = results.get(`${row}:${col}`);
+				if (res) {
+
+					// compare with previous results
+					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 sign = percent > 0 ? '+' : '';
+							let percentText = percent == 0 ? '0%' : sign + percent.toFixed(2) + '%';
+							// diff = ' (' + (percent > 0 ? chalk.red(percentText) : chalk.green(percentText)) + ')'; // alignment is broken
+							diff = ' (' + percentText + ')';
+						}
+						else {
+							diff = chalk.yellow(' (no previous results)');
+						}
+					}
+
+					// add to table
+					curRow.push(formatNumber(res[prop]) + diff);
+				}
+				else {
+					curRow.push('');
+				}
+			}
+			resArr.push(curRow);
+		}
+
+		return markdownTable(resArr, {align: ['l', ...'r'.repeat(schema.cols.length)]});
+	};
+
+	let printResults = () => {
+		logUpdate(`
+			\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')}
+		`);
+	};
+
+	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);
+			printResults();
+		}
+	}
+	logUpdate.done();
+
+	// save results
+	if (options.save) {
+		console.log(`Saving results to ${chalk.gray(absToRel(resultsJsonFile))}`);
+		let json: Record<any, any> = {
+			version: 1,
+			moc: options.moc,
+			dfx: options.dfx,
+			gc: options.gc,
+			forceGc: options.forceGc,
+			results: Array.from(results.entries()),
+		};
+		fs.mkdirSync(path.dirname(resultsJsonFile), {recursive: true});
+		fs.writeFileSync(resultsJsonFile, JSON.stringify(json, (_, val) => {
+			if (typeof val === 'bigint') {
+				return Number(val);
+			}
+			else {
+				return val;
+			}
+		}, 2));
+	}
+
+	return {schema, results};
+}

package/commands/publish.ts

@@ -197,6 +197,10 @@ export async function publish(options: {docs?: boolean, test?: boolean} = {}) {
 		'!tests/**',
 		'!**/*.test.mo',
 		'!**/*.Test.mo',
+		'!bench/**',
+		'!benchmark/**',
+		'!**/*.bench.mo',
+		'!**/*.Bench.mo',
 	];
 	let files = config.package.files || ['**/*.mo'];
 	files = [...files, ...defaultFiles];

package/commands/sources.ts

@@ -4,7 +4,7 @@ import {checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConf
 import {resolvePackages} from '../resolve-packages.js';
 
 // TODO: resolve conflicts
-export async function sources({verbose = false} = {}) {
+export async function sources({verbose = false, cwd = process.cwd()} = {}) {
 	if (!checkConfigFile()) {
 		return [];
 	}
@@ -17,13 +17,13 @@ export async function sources({verbose = false} = {}) {
 
 		let pkgDir;
 		if (depType === 'local') {
-			pkgDir = path.relative(process.cwd(), version);
+			pkgDir = path.relative(cwd, version);
 		}
 		else if (depType === 'github') {
-			pkgDir = path.relative(process.cwd(), formatGithubDir(name, version));
+			pkgDir = path.relative(cwd, formatGithubDir(name, version));
 		}
 		else if (depType === 'mops') {
-			pkgDir = path.relative(process.cwd(), formatDir(name, version));
+			pkgDir = path.relative(cwd, formatDir(name, version));
 		}
 		else {
 			return;

package/declarations/bench/bench.did

@@ -0,0 +1,26 @@
+type anon_class_10_1 = 
+ service {
+   getSchema: () -> (BenchSchema) query;
+   getStats: () -> (BenchResult) query;
+   init: () -> (BenchSchema);
+   runCellQuery: (nat, nat) -> (BenchResult) query;
+   runCellUpdate: (nat, nat) -> (BenchResult);
+   runCellUpdateAwait: (nat, nat) -> (BenchResult);
+ };
+type BenchSchema = 
+ record {
+   cols: vec text;
+   description: text;
+   name: text;
+   rows: vec text;
+ };
+type BenchResult = 
+ record {
+   instructions: int;
+   rts_collector_instructions: int;
+   rts_heap_size: int;
+   rts_memory_size: int;
+   rts_mutator_instructions: int;
+   rts_total_allocation: int;
+ };
+service : () -> anon_class_10_1

package/declarations/bench/bench.did.d.ts

@@ -0,0 +1,26 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+
+export interface BenchResult {
+  'instructions' : bigint,
+  'rts_memory_size' : bigint,
+  'rts_total_allocation' : bigint,
+  'rts_collector_instructions' : bigint,
+  'rts_mutator_instructions' : bigint,
+  'rts_heap_size' : bigint,
+}
+export interface BenchSchema {
+  'cols' : Array<string>,
+  'name' : string,
+  'rows' : Array<string>,
+  'description' : string,
+}
+export interface anon_class_10_1 {
+  'getSchema' : ActorMethod<[], BenchSchema>,
+  'getStats' : ActorMethod<[], BenchResult>,
+  'init' : ActorMethod<[], BenchSchema>,
+  'runCellQuery' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdate' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdateAwait' : ActorMethod<[bigint, bigint], BenchResult>,
+}
+export interface _SERVICE extends anon_class_10_1 {}

package/declarations/bench/bench.did.js

@@ -0,0 +1,26 @@
+export const idlFactory = ({ IDL }) => {
+  const BenchSchema = IDL.Record({
+    'cols' : IDL.Vec(IDL.Text),
+    'name' : IDL.Text,
+    'rows' : IDL.Vec(IDL.Text),
+    'description' : IDL.Text,
+  });
+  const BenchResult = IDL.Record({
+    'instructions' : IDL.Int,
+    'rts_memory_size' : IDL.Int,
+    'rts_total_allocation' : IDL.Int,
+    'rts_collector_instructions' : IDL.Int,
+    'rts_mutator_instructions' : IDL.Int,
+    'rts_heap_size' : IDL.Int,
+  });
+  const anon_class_10_1 = IDL.Service({
+    'getSchema' : IDL.Func([], [BenchSchema], ['query']),
+    'getStats' : IDL.Func([], [BenchResult], ['query']),
+    'init' : IDL.Func([], [BenchSchema], []),
+    'runCellQuery' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], ['query']),
+    'runCellUpdate' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+    'runCellUpdateAwait' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+  });
+  return anon_class_10_1;
+};
+export const init = ({ IDL }) => { return []; };

package/declarations/bench/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@dfinity/agent";
+import type { Principal } from "@dfinity/principal";
+import type { IDL } from "@dfinity/candid";
+
+import { _SERVICE } from './bench.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const bench: ActorSubclass<_SERVICE>;

package/declarations/bench/index.js

@@ -0,0 +1,41 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from "./bench.did.js";
+export { idlFactory } from "./bench.did.js";
+
+/* CANISTER_ID is replaced by webpack based on node environment
+ * Note: canister environment variable will be standardized as
+ * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
+ * beginning in dfx 0.15.0
+ */
+export const canisterId =
+  process.env.CANISTER_ID_BENCH ||
+  process.env.BENCH_CANISTER_ID;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};

package/dist/cli.js

@@ -22,6 +22,7 @@ import { bump } from './commands/bump.js';
 import { sync } from './commands/sync.js';
 import { outdated } from './commands/outdated.js';
 import { update } from './commands/update.js';
+import { bench } from './commands/bench.js';
 import { transferOwnership } from './commands/transfer-ownership.js';
 // import {docs} from './commands/docs.js';
 program.name('mops');
@@ -178,6 +179,18 @@ program
     .action(async (filter, options) => {
     await test(filter, options);
 });
+// bench
+program
+    .command('bench [filter]')
+    .description('Run benchmarks')
+    .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('--gc <gc>', 'Garbage collector').choices(['copying', 'compacting', 'generational', 'incremental']).default('incremental'))
+    // .addOption(new Option('--force-gc', 'Force GC'))
+    .addOption(new Option('--verbose', 'Show more information'))
+    .action(async (filter, options) => {
+    await bench(filter, options);
+});
 // template
 program
     .command('template')

package/dist/commands/bench/bench-canister.mo

@@ -5,7 +5,7 @@ import ExperimentalInternetComputer "mo:base/ExperimentalInternetComputer";
 import Prim "mo:prim";
 import Bench "mo:bench";
 
-import UserBench "./user-bench";
+import UserBench "./user-bench"; // file path will be replaced with the *.bench.mo file path
 
 actor class() {
 	var benchOpt : ?Bench.Bench = null;
@@ -32,48 +32,41 @@ actor class() {
 		}
 	};
 
+	func _diffStats(before : Bench.BenchResult, after : Bench.BenchResult) : Bench.BenchResult {
+		{
+			instructions = after.instructions - before.instructions;
+			rts_heap_size = after.rts_heap_size - before.rts_heap_size;
+			rts_memory_size = after.rts_memory_size - before.rts_memory_size;
+			rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
+			rts_mutator_instructions = after.rts_mutator_instructions - before.rts_mutator_instructions;
+			rts_collector_instructions = after.rts_collector_instructions - before.rts_collector_instructions;
+		}
+	};
+
 	func _runCell(rowIndex : Nat, colIndex : Nat) : Bench.BenchResult {
 		let ?bench = benchOpt else Debug.trap("bench not initialized");
 		let statsBefore = _getStats();
 
-		let instructions = ExperimentalInternetComputer.countInstructions(func() {
+		let instructions = Nat64.toNat(ExperimentalInternetComputer.countInstructions(func() {
 			bench.runCell(rowIndex, colIndex);
-		});
-
-		// await (func() : async () {})();
+		}));
 
 		let statsAfter = _getStats();
-
-		{
-			instructions = Nat64.toNat(instructions);
-			rts_heap_size = statsAfter.rts_heap_size - statsBefore.rts_heap_size;
-			rts_memory_size = statsAfter.rts_memory_size - statsBefore.rts_memory_size;
-			rts_total_allocation = statsAfter.rts_total_allocation - statsBefore.rts_total_allocation;
-			rts_mutator_instructions = statsAfter.rts_mutator_instructions - statsBefore.rts_mutator_instructions;
-			rts_collector_instructions = statsAfter.rts_collector_instructions - statsBefore.rts_collector_instructions;
-		}
+		_diffStats(statsBefore, { statsAfter with instructions });
 	};
 
 	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
 		let ?bench = benchOpt else Debug.trap("bench not initialized");
 		let statsBefore = _getStats();
 
-		let instructions = ExperimentalInternetComputer.countInstructions(func() {
+		let instructions = Nat64.toNat(ExperimentalInternetComputer.countInstructions(func() {
 			bench.runCell(rowIndex, colIndex);
-		});
+		}));
 
 		await (func() : async () {})();
 
 		let statsAfter = _getStats();
-
-		{
-			instructions = Nat64.toNat(instructions);
-			rts_heap_size = statsAfter.rts_heap_size - statsBefore.rts_heap_size;
-			rts_memory_size = statsAfter.rts_memory_size - statsBefore.rts_memory_size;
-			rts_total_allocation = statsAfter.rts_total_allocation - statsBefore.rts_total_allocation;
-			rts_mutator_instructions = statsAfter.rts_mutator_instructions - statsBefore.rts_mutator_instructions;
-			rts_collector_instructions = statsAfter.rts_collector_instructions - statsBefore.rts_collector_instructions;
-		}
+		_diffStats(statsBefore, { statsAfter with instructions });
 	};
 
 	public query func getStats() : async Bench.BenchResult {
@@ -85,10 +78,10 @@ actor class() {
 	};
 
 	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
-		await _runCellAwait(rowIndex, colIndex);
+		_runCell(rowIndex, colIndex);
 	};
 
 	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
-		_runCell(rowIndex, colIndex);
+		await _runCellAwait(rowIndex, colIndex);
 	};
 };

package/dist/commands/bench.js

@@ -36,7 +36,7 @@ export async function bench(filter = '', options = {}) {
         verbose: false,
     };
     options = { ...defaultOptions, ...options };
-    console.log(options);
+    options.verbose && console.log(options);
     let rootDir = getRootDir();
     let globStr = '**/bench?(mark)/**/*.bench.mo';
     if (filter) {
@@ -67,7 +67,14 @@ export async function bench(filter = '', options = {}) {
     startDfx(options.verbose);
     console.log('Deploying canisters...');
     await parallel(os.cpus().length, files, async (file) => {
-        await deployBenchFile(file, options);
+        try {
+            await deployBenchFile(file, options);
+        }
+        catch (err) {
+            console.error('Unexpected error. Stopping dfx replica...');
+            stopDfx(options.verbose);
+            throw err;
+        }
     });
     await parallel(1, files, async (file) => {
         console.log('\n' + '—'.repeat(50));
@@ -118,7 +125,7 @@ function dfxJson(canisterName, options = {}) {
         networks: {
             local: {
                 type: 'ephemeral',
-                bind: '127.0.0.1:4947',
+                bind: '127.0.0.1:4944',
             },
         },
     };
@@ -140,8 +147,9 @@ async function deployBenchFile(file, options = {}) {
     // prepare temp files
     fs.mkdirSync(tempDir, { recursive: true });
     fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(dfxJson(canisterName, options), null, 2));
-    fs.cpSync(new URL('./bench/bench-canister.mo', import.meta.url), path.join(tempDir, 'canister.mo'));
-    fs.cpSync(file, path.join(tempDir, 'user-bench.mo'));
+    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);
@@ -157,7 +165,7 @@ async function deployBenchFile(file, options = {}) {
     let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
     let actor = await createActor(canisterId, {
         agentOptions: {
-            host: 'http://127.0.0.1:4947',
+            host: 'http://127.0.0.1:4944',
         },
     });
     await actor.init();
@@ -170,7 +178,7 @@ async function runBenchFile(file, options = {}) {
     let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
     let actor = await createActor(canisterId, {
         agentOptions: {
-            host: 'http://127.0.0.1:4947',
+            host: 'http://127.0.0.1:4944',
         },
     });
     let schema = await actor.getSchema();
@@ -235,9 +243,9 @@ async function runBenchFile(file, options = {}) {
     // 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.runCellQuery(BigInt(rowIndex), BigInt(colIndex));
             // let res = await actor.runCellUpdate(BigInt(rowIndex), BigInt(colIndex));
-            // let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
+            let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
             results.set(`${row}:${col}`, res);
             printResults();
         }

package/dist/commands/publish.js

@@ -176,6 +176,10 @@ export async function publish(options = {}) {
         '!tests/**',
         '!**/*.test.mo',
         '!**/*.Test.mo',
+        '!bench/**',
+        '!benchmark/**',
+        '!**/*.bench.mo',
+        '!**/*.Bench.mo',
     ];
     let files = config.package.files || ['**/*.mo'];
     files = [...files, ...defaultFiles];

package/dist/commands/sources.d.ts

@@ -1,3 +1,4 @@
-export declare function sources({ verbose }?: {
+export declare function sources({ verbose, cwd }?: {
     verbose?: boolean | undefined;
+    cwd?: string | undefined;
 }): Promise<(string | undefined)[]>;

package/dist/commands/sources.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig } from '../mops.js';
 import { resolvePackages } from '../resolve-packages.js';
 // TODO: resolve conflicts
-export async function sources({ verbose = false } = {}) {
+export async function sources({ verbose = false, cwd = process.cwd() } = {}) {
     if (!checkConfigFile()) {
         return [];
     }
@@ -13,13 +13,13 @@ export async function sources({ verbose = false } = {}) {
         let depType = getDependencyType(version);
         let pkgDir;
         if (depType === 'local') {
-            pkgDir = path.relative(process.cwd(), version);
+            pkgDir = path.relative(cwd, version);
         }
         else if (depType === 'github') {
-            pkgDir = path.relative(process.cwd(), formatGithubDir(name, version));
+            pkgDir = path.relative(cwd, formatGithubDir(name, version));
         }
         else if (depType === 'mops') {
-            pkgDir = path.relative(process.cwd(), formatDir(name, version));
+            pkgDir = path.relative(cwd, formatDir(name, version));
         }
         else {
             return;

package/dist/package.json

@@ -1,82 +1,83 @@
 {
-	"name": "ic-mops",
-	"version": "0.31.2",
-	"type": "module",
-	"bin": {
-		"mops": "dist/cli.js"
-	},
-	"files": [
-		"*",
-		"!network.txt",
-		"!.mops",
-		"/templates"
-	],
-	"homepage": "https://mops.one",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/ZenVoich/mops.git"
-	},
-	"author": "Zen Voich <zen.voich@gmail.com>",
-	"license": "MIT",
-	"engines": {
-		"node": ">=16.0.0"
-	},
-	"scripts": {
-		"build": "tsc",
-		"bundle": "esbuild --bundle --outfile=cli.js --platform=node --packages=external --target=node16 --format=esm ./dist/cli.js",
-		"copy": "cp -r declarations templates network.txt package.json dist | true",
-		"save-network": "cp -r dist/network.txt . | true",
-		"prepare": "npm run save-network && npm run build && npm run copy",
-		"check": "tsc --project tsconfig.json --noEmit",
-		"tsc": "tsc",
-		"esbuild": "esbuild"
-	},
-	"dependencies": {
-		"@dfinity/agent": "^0.18.1",
-		"@dfinity/candid": "^0.18.1",
-		"@dfinity/identity": "^0.18.1",
-		"@dfinity/identity-secp256k1": "^0.18.1",
-		"@dfinity/principal": "^0.18.1",
-		"@iarna/toml": "^2.2.5",
-		"as-table": "^1.0.55",
-		"cacheable-request": "10.2.12",
-		"camelcase": "^7.0.1",
-		"chalk": "^5.3.0",
-		"chokidar": "^3.5.3",
-		"commander": "^11.0.0",
-		"debounce": "^1.2.1",
-		"decompress": "^4.2.1",
-		"del": "^7.0.0",
-		"dhall-to-json-cli": "^1.7.6",
-		"eslint": "^8.45.0",
-		"execa": "7.1.1",
-		"get-folder-size": "^4.0.0",
-		"glob": "^10.3.3",
-		"globby": "^13.2.2",
-		"got": "13.0.0",
-		"log-update": "^5.0.1",
-		"mdast-util-from-markdown": "^2.0.0",
-		"mdast-util-to-markdown": "^2.1.0",
-		"minimatch": "^9.0.3",
-		"ncp": "^2.0.0",
-		"node-fetch": "^3.3.2",
-		"pem-file": "^1.0.1",
-		"prompts": "^2.4.2",
-		"stream-to-promise": "^3.0.0",
-		"tar": "^6.1.15"
-	},
-	"devDependencies": {
-		"@tsconfig/strictest": "^2.0.1",
-		"@types/debounce": "^1.2.1",
-		"@types/decompress": "^4.2.4",
-		"@types/glob": "^8.1.0",
-		"@types/ncp": "^2.0.5",
-		"@types/node": "^20.4.4",
-		"@types/prompts": "^2.4.4",
-		"@types/stream-to-promise": "^2.2.1",
-		"@types/tar": "^6.1.5",
-		"esbuild": "^0.18.16",
-		"tsx": "^3.12.7",
-		"typescript": "^5.1.6"
-	}
+  "name": "ic-mops",
+  "version": "0.32.1",
+  "type": "module",
+  "bin": {
+    "mops": "dist/cli.js"
+  },
+  "files": [
+    "*",
+    "!network.txt",
+    "!.mops",
+    "/templates"
+  ],
+  "homepage": "https://mops.one",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ZenVoich/mops.git"
+  },
+  "author": "Zen Voich <zen.voich@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "bundle": "esbuild --bundle --outfile=cli.js --platform=node --packages=external --target=node16 --format=esm ./dist/cli.js",
+    "copy": "cp -r commands/bench dist/commands && cp -r declarations templates network.txt package.json dist | true",
+    "save-network": "cp -r dist/network.txt . | true",
+    "prepare": "npm run save-network && npm run build && npm run copy",
+    "check": "tsc --project tsconfig.json --noEmit",
+    "tsc": "tsc",
+    "esbuild": "esbuild"
+  },
+  "dependencies": {
+    "@dfinity/agent": "^0.18.1",
+    "@dfinity/candid": "^0.18.1",
+    "@dfinity/identity": "^0.18.1",
+    "@dfinity/identity-secp256k1": "^0.18.1",
+    "@dfinity/principal": "^0.18.1",
+    "@iarna/toml": "^2.2.5",
+    "as-table": "^1.0.55",
+    "cacheable-request": "10.2.12",
+    "camelcase": "^7.0.1",
+    "chalk": "^5.3.0",
+    "chokidar": "^3.5.3",
+    "commander": "^11.0.0",
+    "debounce": "^1.2.1",
+    "decompress": "^4.2.1",
+    "del": "^7.0.0",
+    "dhall-to-json-cli": "^1.7.6",
+    "eslint": "^8.45.0",
+    "execa": "7.1.1",
+    "get-folder-size": "^4.0.0",
+    "glob": "^10.3.3",
+    "globby": "^13.2.2",
+    "got": "13.0.0",
+    "log-update": "^5.0.1",
+    "markdown-table": "3.0.3",
+    "mdast-util-from-markdown": "^2.0.0",
+    "mdast-util-to-markdown": "^2.1.0",
+    "minimatch": "^9.0.3",
+    "ncp": "^2.0.0",
+    "node-fetch": "^3.3.2",
+    "pem-file": "^1.0.1",
+    "prompts": "^2.4.2",
+    "stream-to-promise": "^3.0.0",
+    "tar": "^6.1.15"
+  },
+  "devDependencies": {
+    "@tsconfig/strictest": "^2.0.1",
+    "@types/debounce": "^1.2.1",
+    "@types/decompress": "^4.2.4",
+    "@types/glob": "^8.1.0",
+    "@types/ncp": "^2.0.5",
+    "@types/node": "^20.4.4",
+    "@types/prompts": "^2.4.4",
+    "@types/stream-to-promise": "^2.2.1",
+    "@types/tar": "^6.1.5",
+    "esbuild": "^0.18.16",
+    "tsx": "^3.12.7",
+    "typescript": "^5.1.6"
+  }
 }

package/helpers/get-dfx-version.ts

@@ -0,0 +1,10 @@
+import {execSync} from 'node:child_process';
+
+export function getDfxVersion(): string {
+	try {
+		let res = execSync('dfx --version').toString();
+		return res.trim().split('dfx ')[1] || '';
+	}
+	catch {}
+	return '';
+}

package/helpers/get-moc-path.ts

@@ -0,0 +1,12 @@
+import {execSync} from 'node:child_process';
+
+export function getMocPath(): string {
+	let mocPath = process.env.DFX_MOC_PATH;
+	if (!mocPath) {
+		mocPath = execSync('dfx cache show').toString().trim() + '/moc';
+	}
+	if (!mocPath) {
+		mocPath = 'moc';
+	}
+	return mocPath;
+}

package/helpers/get-moc-version.ts

@@ -0,0 +1,8 @@
+import {execSync} from 'node:child_process';
+import {getMocPath} from './get-moc-path.js';
+
+export function getMocVersion(): string {
+	let mocPath = getMocPath();
+	let match = execSync(mocPath).toString().trim().match(/Motoko compiler ([^\s]+) .*/);
+	return match?.[1] || '';
+}

package/package.json

@@ -1,82 +1,83 @@
 {
-	"name": "ic-mops",
-	"version": "0.31.2",
-	"type": "module",
-	"bin": {
-		"mops": "dist/cli.js"
-	},
-	"files": [
-		"*",
-		"!network.txt",
-		"!.mops",
-		"/templates"
-	],
-	"homepage": "https://mops.one",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/ZenVoich/mops.git"
-	},
-	"author": "Zen Voich <zen.voich@gmail.com>",
-	"license": "MIT",
-	"engines": {
-		"node": ">=16.0.0"
-	},
-	"scripts": {
-		"build": "tsc",
-		"bundle": "esbuild --bundle --outfile=cli.js --platform=node --packages=external --target=node16 --format=esm ./dist/cli.js",
-		"copy": "cp -r declarations templates network.txt package.json dist | true",
-		"save-network": "cp -r dist/network.txt . | true",
-		"prepare": "npm run save-network && npm run build && npm run copy",
-		"check": "tsc --project tsconfig.json --noEmit",
-		"tsc": "tsc",
-		"esbuild": "esbuild"
-	},
-	"dependencies": {
-		"@dfinity/agent": "^0.18.1",
-		"@dfinity/candid": "^0.18.1",
-		"@dfinity/identity": "^0.18.1",
-		"@dfinity/identity-secp256k1": "^0.18.1",
-		"@dfinity/principal": "^0.18.1",
-		"@iarna/toml": "^2.2.5",
-		"as-table": "^1.0.55",
-		"cacheable-request": "10.2.12",
-		"camelcase": "^7.0.1",
-		"chalk": "^5.3.0",
-		"chokidar": "^3.5.3",
-		"commander": "^11.0.0",
-		"debounce": "^1.2.1",
-		"decompress": "^4.2.1",
-		"del": "^7.0.0",
-		"dhall-to-json-cli": "^1.7.6",
-		"eslint": "^8.45.0",
-		"execa": "7.1.1",
-		"get-folder-size": "^4.0.0",
-		"glob": "^10.3.3",
-		"globby": "^13.2.2",
-		"got": "13.0.0",
-		"log-update": "^5.0.1",
-		"mdast-util-from-markdown": "^2.0.0",
-		"mdast-util-to-markdown": "^2.1.0",
-		"minimatch": "^9.0.3",
-		"ncp": "^2.0.0",
-		"node-fetch": "^3.3.2",
-		"pem-file": "^1.0.1",
-		"prompts": "^2.4.2",
-		"stream-to-promise": "^3.0.0",
-		"tar": "^6.1.15"
-	},
-	"devDependencies": {
-		"@tsconfig/strictest": "^2.0.1",
-		"@types/debounce": "^1.2.1",
-		"@types/decompress": "^4.2.4",
-		"@types/glob": "^8.1.0",
-		"@types/ncp": "^2.0.5",
-		"@types/node": "^20.4.4",
-		"@types/prompts": "^2.4.4",
-		"@types/stream-to-promise": "^2.2.1",
-		"@types/tar": "^6.1.5",
-		"esbuild": "^0.18.16",
-		"tsx": "^3.12.7",
-		"typescript": "^5.1.6"
-	}
+  "name": "ic-mops",
+  "version": "0.32.1",
+  "type": "module",
+  "bin": {
+    "mops": "dist/cli.js"
+  },
+  "files": [
+    "*",
+    "!network.txt",
+    "!.mops",
+    "/templates"
+  ],
+  "homepage": "https://mops.one",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ZenVoich/mops.git"
+  },
+  "author": "Zen Voich <zen.voich@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "bundle": "esbuild --bundle --outfile=cli.js --platform=node --packages=external --target=node16 --format=esm ./dist/cli.js",
+    "copy": "cp -r commands/bench dist/commands && cp -r declarations templates network.txt package.json dist | true",
+    "save-network": "cp -r dist/network.txt . | true",
+    "prepare": "npm run save-network && npm run build && npm run copy",
+    "check": "tsc --project tsconfig.json --noEmit",
+    "tsc": "tsc",
+    "esbuild": "esbuild"
+  },
+  "dependencies": {
+    "@dfinity/agent": "^0.18.1",
+    "@dfinity/candid": "^0.18.1",
+    "@dfinity/identity": "^0.18.1",
+    "@dfinity/identity-secp256k1": "^0.18.1",
+    "@dfinity/principal": "^0.18.1",
+    "@iarna/toml": "^2.2.5",
+    "as-table": "^1.0.55",
+    "cacheable-request": "10.2.12",
+    "camelcase": "^7.0.1",
+    "chalk": "^5.3.0",
+    "chokidar": "^3.5.3",
+    "commander": "^11.0.0",
+    "debounce": "^1.2.1",
+    "decompress": "^4.2.1",
+    "del": "^7.0.0",
+    "dhall-to-json-cli": "^1.7.6",
+    "eslint": "^8.45.0",
+    "execa": "7.1.1",
+    "get-folder-size": "^4.0.0",
+    "glob": "^10.3.3",
+    "globby": "^13.2.2",
+    "got": "13.0.0",
+    "log-update": "^5.0.1",
+    "markdown-table": "3.0.3",
+    "mdast-util-from-markdown": "^2.0.0",
+    "mdast-util-to-markdown": "^2.1.0",
+    "minimatch": "^9.0.3",
+    "ncp": "^2.0.0",
+    "node-fetch": "^3.3.2",
+    "pem-file": "^1.0.1",
+    "prompts": "^2.4.2",
+    "stream-to-promise": "^3.0.0",
+    "tar": "^6.1.15"
+  },
+  "devDependencies": {
+    "@tsconfig/strictest": "^2.0.1",
+    "@types/debounce": "^1.2.1",
+    "@types/decompress": "^4.2.4",
+    "@types/glob": "^8.1.0",
+    "@types/ncp": "^2.0.5",
+    "@types/node": "^20.4.4",
+    "@types/prompts": "^2.4.4",
+    "@types/stream-to-promise": "^2.2.1",
+    "@types/tar": "^6.1.5",
+    "esbuild": "^0.18.16",
+    "tsx": "^3.12.7",
+    "typescript": "^5.1.6"
+  }
 }

package/tsconfig.json

@@ -10,6 +10,8 @@
 		"module": "nodenext",
 		"moduleResolution": "nodenext",
 		"noEmitOnError": false,
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
 		"noPropertyAccessFromIndexSignature": false,
 		"declaration": true
 	}