ic-mops 0.45.4-pre.0 → 1.0.0-pre.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## unreleased
 - `mops cache clean` now cleans local cache too (`.mops` folder)
+- Conflicting dependencies are now reported on `mops add/install/sources`
+- New `--conflicts <action>` option in `mops sources` command ([docs](https://docs.mops.one/cli/mops-sources#--conflicts))
+- New "Stable Memory" and "Garbage Collection" metrics are now reported in the `mops bench` command
+- `mops test` command now supports `replica` mode for running actor tests ([docs](https://docs.mops.one/cli/mops-test#--mode))
+- New `--replica` option in `mops test` command
+
+**Breaking changes**:
+- Default replica in `mops bench` commands now is `pocket-ic` if `pocket-ic` is specified in `mops.toml` in `[toolchain]` section
+- The only supported version of `pocket-ic` is `4.0.0`
+- Removed the ability to install a specific package with `mops install <pkg>` command. Use `mops add <pkg>` instead.
+- Default reporter in `mops test` command is now `verbose` if there is only one file to test and `files` otherwise.
+- Removed legacy folders migration code. If you are using Mops CLI  `<= 0.21.0`, you need first to run `npm i -g ic-mops@0.45.3` to migrate your legacy folders. After that, you can run `mops self update` to update your Mops CLI to the latest version.
+- Renamed `mops import-identity` command to `mops user import`
+- Renamed `mops whoami` command to `mops user get-principal`
 
 ## 0.45.3
 - Fixed bug with missing `tar` package

package/README.md

@@ -89,7 +89,7 @@ dfx identity new mops
 Import identity into `mops`
 
 ```
-mops import-identity -- "$(dfx identity export mops)"
+mops user import -- "$(dfx identity export mops)"
 ```
 
 ### 2. Initialize

package/api/actors.ts

@@ -8,7 +8,7 @@ import {_SERVICE as _STORAGE_SERVICE} from '../declarations/storage/storage.did.
 import {getEndpoint} from './network.js';
 import {getNetwork} from './network.js';
 
-let agentPromiseByPrincipal = new Map <string, Promise<HttpAgent>>();
+let agentPromiseByPrincipal = new Map<string, Promise<HttpAgent>>();
 
 let getAgent = async (identity ?: Identity) : Promise<HttpAgent> => {
 	let principal = identity ? identity?.getPrincipal().toText() : '';

package/cache.ts

@@ -3,15 +3,20 @@ import path from 'node:path';
 import ncp from 'ncp';
 import getFolderSize from 'get-folder-size';
 
-import {getDependencyType, getRootDir, globalCacheDir, parseGithubURL} from './mops.js';
+import {getDependencyType, getNetwork, getRootDir, globalCacheDir, parseGithubURL} from './mops.js';
 import {getPackageId} from './helpers/get-package-id.js';
 
+let getGlobalCacheDir = () => {
+	let network = getNetwork();
+	return path.join(globalCacheDir, network === 'ic' ? '' : network);
+};
+
 export let show = () => {
-	return globalCacheDir;
+	return getGlobalCacheDir();
 };
 
 export let getDepCacheDir = (cacheName : string) => {
-	return path.join(globalCacheDir, 'packages', cacheName);
+	return path.join(getGlobalCacheDir(), 'packages', cacheName);
 };
 
 export let isDepCached = (cacheName : string) => {
@@ -34,7 +39,7 @@ export function getGithubDepCacheName(name : string, repo : string) {
 }
 
 export let addCache = (cacheName : string, source : string) => {
-	let dest = path.join(globalCacheDir, 'packages', cacheName);
+	let dest = path.join(getGlobalCacheDir(), 'packages', cacheName);
 	fs.mkdirSync(dest, {recursive: true});
 
 	return new Promise<void>((resolve, reject) => {
@@ -48,7 +53,7 @@ export let addCache = (cacheName : string, source : string) => {
 };
 
 export let copyCache = (cacheName : string, dest : string) => {
-	let source = path.join(globalCacheDir, 'packages', cacheName);
+	let source = path.join(getGlobalCacheDir(), 'packages', cacheName);
 	fs.mkdirSync(dest, {recursive: true});
 
 	return new Promise<void>((resolve, reject) => {
@@ -62,7 +67,7 @@ export let copyCache = (cacheName : string, dest : string) => {
 };
 
 export let cacheSize = async () => {
-	let dir = path.join(globalCacheDir);
+	let dir = path.join(getGlobalCacheDir());
 	fs.mkdirSync(dir, {recursive: true});
 
 	let size = await getFolderSize.strict(dir);
@@ -73,13 +78,13 @@ export let cacheSize = async () => {
 };
 
 export let cleanCache = async () => {
-	if (!globalCacheDir.endsWith('mops/cache') && !globalCacheDir.endsWith('/mops')) {
-		throw new Error('Invalid cache directory: ' + globalCacheDir);
+	if (!getGlobalCacheDir().endsWith('mops/cache') && !getGlobalCacheDir().endsWith('/mops') && !getGlobalCacheDir().endsWith('/mops/' + getNetwork())) {
+		throw new Error('Invalid cache directory: ' + getGlobalCacheDir());
 	}
 
 	// local cache
 	fs.rmSync(path.join(getRootDir(), '.mops'), {recursive: true, force: true});
 
 	// global cache
-	fs.rmSync(globalCacheDir, {recursive: true, force: true});
+	fs.rmSync(getGlobalCacheDir(), {recursive: true, force: true});
 };

package/cli.ts

@@ -1,15 +1,12 @@
 import process from 'node:process';
 import fs from 'node:fs';
 import {Command, Argument, Option} from 'commander';
-import chalk from 'chalk';
 
 import {init} from './commands/init.js';
 import {publish} from './commands/publish.js';
-import {importPem} from './commands/import-identity.js';
 import {sources} from './commands/sources.js';
 import {checkApiCompatibility, setNetwork, apiVersion, checkConfigFile, getNetworkFile, version} from './mops.js';
 import {getNetwork} from './api/network.js';
-import {whoami} from './commands/whoami.js';
 import {installAll} from './commands/install/install-all.js';
 import {search} from './commands/search.js';
 import {add} from './commands/add.js';
@@ -17,7 +14,7 @@ import {cacheSize, cleanCache, show} from './cache.js';
 import {test} from './commands/test/test.js';
 import {template} from './commands/template.js';
 import {remove} from './commands/remove.js';
-import {getUserProp, setUserProp} from './commands/user.js';
+import {importPem, getPrincipal, getUserProp, setUserProp} from './commands/user.js';
 import {bump} from './commands/bump.js';
 import {sync} from './commands/sync.js';
 import {outdated} from './commands/outdated.js';
@@ -27,11 +24,14 @@ import {transferOwnership} from './commands/transfer-ownership.js';
 import {toolchain} from './commands/toolchain/index.js';
 import {Tool} from './types.js';
 import * as self from './commands/self.js';
+import {resolvePackages} from './resolve-packages.js';
 // import {docs} from './commands/docs.js';
 
 declare global {
 	// eslint-disable-next-line no-var
 	var MOPS_NETWORK : string;
+	// eslint-disable-next-line no-var
+	var mopsReplicaTestRunning : boolean;
 }
 
 let networkFile = getNetworkFile();
@@ -87,12 +87,12 @@ program
 
 // install
 program
-	.command('install [pkg]')
+	.command('install')
 	.alias('i')
 	.description('Install all dependencies specified in mops.toml')
 	.option('--verbose')
 	.addOption(new Option('--lock <action>', 'Lockfile action').choices(['check', 'update', 'ignore']))
-	.action(async (pkg, options) => {
+	.action(async (options) => {
 		if (!checkConfigFile()) {
 			process.exit(1);
 		}
@@ -104,17 +104,14 @@ program
 
 		await toolchain.ensureToolchainInited({strict: false});
 
-		if (pkg) {
-			// @deprecated
-			console.log(chalk.yellow('Consider using the \'mops add\' command to install a specific package.'));
-			await add(pkg, options);
-		}
-		else {
-			let ok = await installAll(options);
-			await toolchain.installAll(options);
-			if (!ok) {
-				process.exit(1);
-			}
+		let ok = await installAll(options);
+		await toolchain.installAll(options);
+
+		// check conflicts
+		await resolvePackages({conflicts: 'warning'});
+
+		if (!ok) {
+			process.exit(1);
 		}
 	});
 
@@ -155,14 +152,14 @@ program
 		console.log(getNetwork());
 	});
 
-// import-identity
+// user import
 program
-	.command('import-identity <data>')
+	.command('mops user import <data>')
 	.description('Import .pem file data to use as identity')
 	.addOption(new Option('--no-encrypt', 'Do not ask for a password to encrypt identity'))
 	.action(async (data, options) => {
 		await importPem(data, options);
-		await whoami();
+		await getPrincipal();
 	});
 
 // sources
@@ -170,7 +167,8 @@ program
 	.command('sources')
 	.description('for dfx packtool')
 	.option('--no-install', 'Do not install dependencies before running sources')
-	.option('--verbose')
+	.addOption(new Option('--conflicts <action>', 'What to do with dependency version conflicts').choices(['ignore', 'warning', 'error']).default('warning'))
+	.option('--verbose', 'Show more information') // for backcompat
 	.action(async (options) => {
 		if (!checkConfigFile()) {
 			process.exit(1);
@@ -183,12 +181,12 @@ program
 		console.log(sourcesArr.join('\n'));
 	});
 
-// whoami
+// get-principal
 program
-	.command('whoami')
+	.command('get-principal')
 	.description('Print your principal')
 	.action(async () => {
-		await whoami();
+		await getPrincipal();
 	});
 
 // search
@@ -222,10 +220,12 @@ program
 program
 	.command('test [filter]')
 	.description('Run tests')
-	.addOption(new Option('-r, --reporter <reporter>', 'Test reporter').choices(['verbose', 'compact', 'files', 'silent']).default('verbose'))
-	.addOption(new Option('--mode <mode>', 'Test mode').choices(['interpreter', 'wasi']).default('interpreter'))
+	.addOption(new Option('-r, --reporter <reporter>', 'Test reporter').choices(['verbose', 'compact', 'files', 'silent']))
+	.addOption(new Option('--mode <mode>', 'Test mode').choices(['interpreter', 'wasi', 'replica']).default('interpreter'))
+	.addOption(new Option('--replica <replica>', 'Which replica to use to run tests in replica mode').choices(['dfx', 'pocket-ic']))
 	.option('-w, --watch', 'Enable watch mode')
 	.action(async (filter, options) => {
+		checkConfigFile(true);
 		await installAll({silent: true, lock: 'ignore'});
 		await test(filter, options);
 	});
@@ -234,13 +234,14 @@ program
 program
 	.command('bench [filter]')
 	.description('Run benchmarks')
-	.addOption(new Option('--replica <replica>', 'Which replica to use to run benchmarks').choices(['dfx', 'pocket-ic']).default('dfx'))
+	.addOption(new Option('--replica <replica>', 'Which replica to use to run benchmarks').choices(['dfx', 'pocket-ic']))
 	.addOption(new Option('--gc <gc>', 'Garbage collector').choices(['copying', 'compacting', 'generational', 'incremental']).default('copying'))
 	.addOption(new Option('--save', 'Save benchmark results to .bench/<filename>.json'))
 	.addOption(new Option('--compare', 'Run benchmark and compare results with .bench/<filename>.json'))
 	// .addOption(new Option('--force-gc', 'Force GC'))
 	.addOption(new Option('--verbose', 'Show more information'))
 	.action(async (filter, options) => {
+		checkConfigFile(true);
 		await installAll({silent: true, lock: 'ignore'});
 		await bench(filter, options);
 	});

package/commands/add.ts

@@ -10,6 +10,7 @@ import {checkIntegrity} from '../integrity.js';
 import {checkRequirements} from '../check-requirements.js';
 import {syncLocalCache} from './install/sync-local-cache.js';
 import {notifyInstalls} from '../notify-installs.js';
+import {resolvePackages} from '../resolve-packages.js';
 
 type AddOptions = {
 	verbose ?: boolean;
@@ -127,4 +128,7 @@ export async function add(name : string, {verbose = false, dev = false, lock} :
 	await checkRequirements({verbose});
 
 	console.log(chalk.green('Package installed ') + `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);
+
+	// check conflicts
+	await resolvePackages({conflicts: 'warning'});
 }

package/commands/bench/bench-canister.mo

@@ -2,17 +2,35 @@ import Nat64 "mo:base/Nat64";
 import Nat "mo:base/Nat";
 import Debug "mo:base/Debug";
 import ExperimentalInternetComputer "mo:base/ExperimentalInternetComputer";
+import ExperimentalStableMemory "mo:base/ExperimentalStableMemory";
+import Int64 "mo:base/Int64";
+import Region "mo:base/Region";
 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() {
+	type BenchResult = {
+		instructions : Int;
+		rts_mutator_instructions : Int;
+		stable_memory_size : Int;
+		rts_stable_memory_size : Int;
+		rts_logical_stable_memory_size : Int;
+		rts_collector_instructions : Int;
+		rts_heap_size : Int;
+		rts_memory_size : Int;
+		rts_total_allocation : Int;
+		rts_reclaimed : Int;
+	};
+
 	var benchOpt : ?Bench.Bench = null;
 
 	public func init() : async Bench.BenchSchema {
 		let bench = UserBench.init();
 		benchOpt := ?bench;
+		// ignore ExperimentalStableMemory.grow(1);
+		ignore Region.grow(Region.new(), 1);
 		bench.getSchema();
 	};
 
@@ -21,29 +39,37 @@ actor class() {
 		bench.getSchema();
 	};
 
-	func _getStats() : Bench.BenchResult {
+	func _getStats() : BenchResult {
 		{
 			instructions = 0;
 			rts_heap_size = Prim.rts_heap_size();
+			stable_memory_size = Int64.toInt(Int64.fromNat64(ExperimentalStableMemory.size())) * 65536;
+			rts_stable_memory_size = Prim.rts_stable_memory_size();
+			rts_logical_stable_memory_size = Prim.rts_logical_stable_memory_size();
 			rts_memory_size = Prim.rts_memory_size();
 			rts_total_allocation = Prim.rts_total_allocation();
+			rts_reclaimed = Prim.rts_reclaimed();
 			rts_mutator_instructions = Prim.rts_mutator_instructions();
 			rts_collector_instructions = Prim.rts_collector_instructions();
 		}
 	};
 
-	func _diffStats(before : Bench.BenchResult, after : Bench.BenchResult) : Bench.BenchResult {
+	func _diffStats(before : BenchResult, after : BenchResult) : BenchResult {
 		{
 			instructions = after.instructions - before.instructions;
 			rts_heap_size = after.rts_heap_size - before.rts_heap_size;
+			stable_memory_size = after.stable_memory_size - before.stable_memory_size;
+			rts_stable_memory_size = after.rts_stable_memory_size - before.rts_stable_memory_size;
+			rts_logical_stable_memory_size = after.rts_logical_stable_memory_size - before.rts_logical_stable_memory_size;
 			rts_memory_size = after.rts_memory_size - before.rts_memory_size;
 			rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
+			rts_reclaimed = after.rts_reclaimed - before.rts_reclaimed;
 			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 {
+	func _runCell(rowIndex : Nat, colIndex : Nat) : BenchResult {
 		let ?bench = benchOpt else Debug.trap("bench not initialized");
 		let statsBefore = _getStats();
 
@@ -55,7 +81,7 @@ actor class() {
 		_diffStats(statsBefore, { statsAfter with instructions });
 	};
 
-	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
 		let ?bench = benchOpt else Debug.trap("bench not initialized");
 		let statsBefore = _getStats();
 
@@ -69,19 +95,19 @@ actor class() {
 		_diffStats(statsBefore, { statsAfter with instructions });
 	};
 
-	public query func getStats() : async Bench.BenchResult {
+	public query func getStats() : async BenchResult {
 		_getStats();
 	};
 
-	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async BenchResult {
 		_runCell(rowIndex, colIndex);
 	};
 
-	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async BenchResult {
 		_runCell(rowIndex, colIndex);
 	};
 
-	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
 		await _runCellAwait(rowIndex, colIndex);
 	};
 };

package/commands/bench-replica.ts

@@ -3,7 +3,7 @@ import {execSync} from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import {execaCommand} from 'execa';
-import {PocketIc} from 'pic-ic';
+import {PocketIc, PocketIcServer} from 'pic-ic';
 import {getRootDir, readConfig} from '../mops.js';
 import {createActor, idlFactory} from '../declarations/bench/index.js';
 import {toolchain} from './toolchain/index.js';
@@ -12,6 +12,7 @@ export class BenchReplica {
 	type : 'dfx' | 'pocket-ic';
 	verbose = false;
 	canisters : Record<string, {cwd : string; canisterId : string; actor : any;}> = {};
+	pocketIcServer ?: PocketIcServer;
 	pocketIc ?: PocketIc;
 
 	constructor(type : 'dfx' | 'pocket-ic', verbose = false) {
@@ -31,11 +32,14 @@ export class BenchReplica {
 		else {
 			let pocketIcBin = await toolchain.bin('pocket-ic');
 			let config = readConfig();
-			if (config.toolchain?.['pocket-ic'] !== '1.0.0') {
-				console.error('Currently only pocket-ic 1.0.0 is supported');
+			if (config.toolchain?.['pocket-ic'] !== '4.0.0') {
+				console.error('Current Mops CLI only supports pocket-ic 4.0.0');
 				process.exit(1);
 			}
-			this.pocketIc = await PocketIc.create(pocketIcBin);
+			this.pocketIcServer = await PocketIcServer.start({
+				binPath: pocketIcBin,
+			});
+			this.pocketIc = await PocketIc.create(this.pocketIcServer.getUrl());
 		}
 	}
 
@@ -44,8 +48,9 @@ export class BenchReplica {
 			let dir = path.join(getRootDir(), '.mops/.bench');
 			execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), {cwd: dir, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe']});
 		}
-		else if (this.pocketIc) {
+		else if (this.pocketIc && this.pocketIcServer) {
 			await this.pocketIc.tearDown();
+			await this.pocketIcServer.stop();
 		}
 	}
 
@@ -61,7 +66,7 @@ export class BenchReplica {
 			this.canisters[name] = {cwd, canisterId, actor};
 		}
 		else if (this.pocketIc) {
-			let {canisterId, actor} = await this.pocketIc.setupCanister(idlFactory, wasm);
+			let {canisterId, actor} = await this.pocketIc.setupCanister({idlFactory, wasm});
 			this.canisters[name] = {
 				cwd,
 				canisterId: canisterId.toText(),

package/commands/bench.ts

@@ -20,6 +20,7 @@ import {sources} from './sources.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';
+import {filesize} from 'filesize';
 
 let ignore = [
 	'**/node_modules/**',
@@ -48,8 +49,10 @@ type BenchOptions = {
 };
 
 export async function bench(filter = '', optionsArg : Partial<BenchOptions> = {}) : Promise<Benchmarks> {
+	let config = readConfig();
+
 	let defaultOptions : BenchOptions = {
-		replica: 'dfx',
+		replica: config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx',
 		replicaVersion: '',
 		compiler: 'moc',
 		compilerVersion: getMocVersion(),
@@ -67,7 +70,6 @@ export async function bench(filter = '', optionsArg : Partial<BenchOptions> = {}
 		options.replicaVersion = getDfxVersion();
 	}
 	else if (options.replica == 'pocket-ic') {
-		let config = readConfig();
 		options.replicaVersion = config.toolchain?.['pocket-ic'] || '';
 	}
 
@@ -96,7 +98,7 @@ export async function bench(filter = '', optionsArg : Partial<BenchOptions> = {}
 	files.sort();
 
 	let benchDir = `${getRootDir()}/.mops/.bench/`;
-	fs.rmSync(benchDir, {recursive: true, force: true});
+	// fs.rmSync(benchDir, {recursive: true, force: true});
 	fs.mkdirSync(benchDir, {recursive: true});
 
 	if (!options.silent) {
@@ -145,7 +147,7 @@ export async function bench(filter = '', optionsArg : Partial<BenchOptions> = {}
 	options.silent || console.log('Stopping replica...');
 	await replica.stop();
 
-	fs.rmSync(benchDir, {recursive: true, force: true});
+	// fs.rmSync(benchDir, {recursive: true, force: true});
 
 	return benchResults;
 }
@@ -219,11 +221,17 @@ async function runBenchFile(file : string, options : BenchOptions, replica : Ben
 
 	let instructionsCells : bigint[][] = Array.from({length: schema.rows.length}, () => []);
 	let heapCells : bigint[][] = Array.from({length: schema.rows.length}, () => []);
+	let logicalStableMemoryCells : bigint[][] = Array.from({length: schema.rows.length}, () => []);
+	let reclaimedCells : bigint[][] = Array.from({length: schema.rows.length}, () => []);
 
 	let formatNumber = (n : bigint | number) : string => {
 		return n.toLocaleString('en-US').replaceAll(',', '_');
 	};
 
+	let formatSize = (n : bigint | number) : string => {
+		return filesize(n, {standard: 'iec', round: 2});
+	};
+
 	let getTable = (prop : keyof BenchResult) : string => {
 		let resArr = [['', ...schema.cols]];
 
@@ -251,7 +259,17 @@ async function runBenchFile(file : string, options : BenchOptions, replica : Ben
 					}
 
 					// add to table
-					curRow.push(formatNumber(res[prop]) + diff);
+					let value = '';
+					if (prop == 'rts_logical_stable_memory_size') {
+						value = formatSize(res[prop] * 65536n);
+					}
+					else if (prop === 'rts_heap_size' || prop == 'rts_reclaimed') {
+						value = formatSize(res[prop]);
+					}
+					else {
+						value = formatNumber(res[prop]);
+					}
+					curRow.push(value + diff);
 				}
 				else {
 					curRow.push('');
@@ -272,6 +290,8 @@ async function runBenchFile(file : string, options : BenchOptions, replica : Ben
 			${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('Stable Memory')}\n\n${getTable('rts_logical_stable_memory_size')}
+			\n\n${chalk.blue('Garbage Collection')}\n\n${getTable('rts_reclaimed')}
 		`);
 	};
 
@@ -289,6 +309,10 @@ async function runBenchFile(file : string, options : BenchOptions, replica : Ben
 			instructionsCells[rowIndex][colIndex] = res.instructions;
 			// @ts-ignore
 			heapCells[rowIndex][colIndex] = res.rts_heap_size;
+			// @ts-ignore
+			logicalStableMemoryCells[rowIndex][colIndex] = res.rts_logical_stable_memory_size;
+			// @ts-ignore
+			reclaimedCells[rowIndex][colIndex] = res.rts_reclaimed;
 
 			if (!process.env.CI && !options.silent) {
 				printResults();
@@ -340,6 +364,8 @@ async function runBenchFile(file : string, options : BenchOptions, replica : Ben
 		metrics: [
 			['instructions', instructionsCells],
 			['rts_heap_size', heapCells],
+			['rts_logical_stable_memory_size', logicalStableMemoryCells],
+			['rts_reclaimed', reclaimedCells],
 		],
 	};
 }

package/commands/publish.ts

@@ -271,7 +271,7 @@ export async function publish(options : {docs ?: boolean, test ?: boolean, bench
 	let reporter = new SilentReporter;
 	if (options.test) {
 		console.log('Running tests...');
-		await testWithReporter(reporter);
+		await testWithReporter(reporter, '', 'interpreter', config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx');
 		if (reporter.failed > 0) {
 			console.log(chalk.red('Error: ') + 'tests failed');
 			process.exit(1);