ic-mops 0.28.0 → 0.28.2

package/dist/commands/bench/declarations/main/main.did.js

@@ -0,0 +1,242 @@
+export const idlFactory = ({ IDL }) => {
+    const TestsChanges = IDL.Record({
+        'addedNames': IDL.Vec(IDL.Text),
+        'removedNames': IDL.Vec(IDL.Text),
+    });
+    const DepChange = IDL.Record({
+        'oldVersion': IDL.Text,
+        'name': IDL.Text,
+        'newVersion': IDL.Text,
+    });
+    const PackageChanges__1 = IDL.Record({
+        'tests': TestsChanges,
+        'deps': IDL.Vec(DepChange),
+        'notes': IDL.Text,
+        'devDeps': IDL.Vec(DepChange),
+    });
+    const PublishingId = IDL.Text;
+    const Err = IDL.Text;
+    const Result = IDL.Variant({ 'ok': IDL.Null, 'err': Err });
+    const Text = IDL.Text;
+    const PackageName__1 = IDL.Text;
+    const PackageVersion = IDL.Text;
+    const PackageId = IDL.Text;
+    const Time = IDL.Int;
+    const DownloadsSnapshot__1 = IDL.Record({
+        'startTime': Time,
+        'endTime': Time,
+        'downloads': IDL.Nat,
+    });
+    const FileId = IDL.Text;
+    const Result_7 = IDL.Variant({ 'ok': IDL.Vec(FileId), 'err': Err });
+    const SemverPart = IDL.Variant({
+        'major': IDL.Null,
+        'minor': IDL.Null,
+        'patch': IDL.Null,
+    });
+    const Result_6 = IDL.Variant({
+        'ok': IDL.Vec(IDL.Tuple(PackageName__1, PackageVersion)),
+        'err': Err,
+    });
+    const Result_5 = IDL.Variant({ 'ok': PackageVersion, 'err': Err });
+    const User = IDL.Record({
+        'id': IDL.Principal,
+        'emailVerified': IDL.Bool,
+        'twitter': IDL.Text,
+        'displayName': IDL.Text,
+        'name': IDL.Text,
+        'site': IDL.Text,
+        'email': IDL.Text,
+        'twitterVerified': IDL.Bool,
+        'githubVerified': IDL.Bool,
+        'github': IDL.Text,
+    });
+    const Script = IDL.Record({ 'value': IDL.Text, 'name': IDL.Text });
+    const PackageName = IDL.Text;
+    const DependencyV2 = IDL.Record({
+        'name': PackageName,
+        'repo': IDL.Text,
+        'version': IDL.Text,
+    });
+    const PackageConfigV2__1 = IDL.Record({
+        'dfx': IDL.Text,
+        'moc': IDL.Text,
+        'scripts': IDL.Vec(Script),
+        'baseDir': IDL.Text,
+        'documentation': IDL.Text,
+        'name': PackageName,
+        'homepage': IDL.Text,
+        'description': IDL.Text,
+        'version': IDL.Text,
+        'keywords': IDL.Vec(IDL.Text),
+        'donation': IDL.Text,
+        'devDependencies': IDL.Vec(DependencyV2),
+        'repository': IDL.Text,
+        'dependencies': IDL.Vec(DependencyV2),
+        'license': IDL.Text,
+        'readme': IDL.Text,
+    });
+    const PackagePublication = IDL.Record({
+        'storage': IDL.Principal,
+        'time': Time,
+        'user': IDL.Principal,
+    });
+    const PackageSummary = IDL.Record({
+        'ownerInfo': User,
+        'owner': IDL.Principal,
+        'downloadsTotal': IDL.Nat,
+        'downloadsInLast30Days': IDL.Nat,
+        'downloadsInLast7Days': IDL.Nat,
+        'config': PackageConfigV2__1,
+        'publication': PackagePublication,
+    });
+    const PackageSummary__1 = IDL.Record({
+        'ownerInfo': User,
+        'owner': IDL.Principal,
+        'downloadsTotal': IDL.Nat,
+        'downloadsInLast30Days': IDL.Nat,
+        'downloadsInLast7Days': IDL.Nat,
+        'config': PackageConfigV2__1,
+        'publication': PackagePublication,
+    });
+    const TestStats__1 = IDL.Record({
+        'passedNames': IDL.Vec(IDL.Text),
+        'passed': IDL.Nat,
+    });
+    const DownloadsSnapshot = IDL.Record({
+        'startTime': Time,
+        'endTime': Time,
+        'downloads': IDL.Nat,
+    });
+    const PackageFileStatsPublic = IDL.Record({
+        'sourceFiles': IDL.Nat,
+        'sourceSize': IDL.Nat,
+    });
+    const PackageChanges = IDL.Record({
+        'tests': TestsChanges,
+        'deps': IDL.Vec(DepChange),
+        'notes': IDL.Text,
+        'devDeps': IDL.Vec(DepChange),
+    });
+    const PackageSummaryWithChanges__1 = IDL.Record({
+        'ownerInfo': User,
+        'owner': IDL.Principal,
+        'downloadsTotal': IDL.Nat,
+        'downloadsInLast30Days': IDL.Nat,
+        'downloadsInLast7Days': IDL.Nat,
+        'config': PackageConfigV2__1,
+        'changes': PackageChanges,
+        'publication': PackagePublication,
+    });
+    const PackageDetails = IDL.Record({
+        'ownerInfo': User,
+        'owner': IDL.Principal,
+        'deps': IDL.Vec(PackageSummary__1),
+        'testStats': TestStats__1,
+        'downloadsTotal': IDL.Nat,
+        'downloadsInLast30Days': IDL.Nat,
+        'downloadTrend': IDL.Vec(DownloadsSnapshot),
+        'fileStats': PackageFileStatsPublic,
+        'versionHistory': IDL.Vec(PackageSummaryWithChanges__1),
+        'dependents': IDL.Vec(PackageSummary__1),
+        'devDeps': IDL.Vec(PackageSummary__1),
+        'downloadsInLast7Days': IDL.Nat,
+        'config': PackageConfigV2__1,
+        'changes': PackageChanges,
+        'publication': PackagePublication,
+    });
+    const Result_4 = IDL.Variant({ 'ok': PackageDetails, 'err': Err });
+    const PackageSummaryWithChanges = IDL.Record({
+        'ownerInfo': User,
+        'owner': IDL.Principal,
+        'downloadsTotal': IDL.Nat,
+        'downloadsInLast30Days': IDL.Nat,
+        'downloadsInLast7Days': IDL.Nat,
+        'config': PackageConfigV2__1,
+        'changes': PackageChanges,
+        'publication': PackagePublication,
+    });
+    const StorageId = IDL.Principal;
+    const StorageStats = IDL.Record({
+        'fileCount': IDL.Nat,
+        'cyclesBalance': IDL.Nat,
+        'memorySize': IDL.Nat,
+    });
+    const User__1 = IDL.Record({
+        'id': IDL.Principal,
+        'emailVerified': IDL.Bool,
+        'twitter': IDL.Text,
+        'displayName': IDL.Text,
+        'name': IDL.Text,
+        'site': IDL.Text,
+        'email': IDL.Text,
+        'twitterVerified': IDL.Bool,
+        'githubVerified': IDL.Bool,
+        'github': IDL.Text,
+    });
+    const PageCount = IDL.Nat;
+    const Result_3 = IDL.Variant({ 'ok': IDL.Null, 'err': IDL.Text });
+    const Result_2 = IDL.Variant({ 'ok': FileId, 'err': Err });
+    const PackageConfigV2 = IDL.Record({
+        'dfx': IDL.Text,
+        'moc': IDL.Text,
+        'scripts': IDL.Vec(Script),
+        'baseDir': IDL.Text,
+        'documentation': IDL.Text,
+        'name': PackageName,
+        'homepage': IDL.Text,
+        'description': IDL.Text,
+        'version': IDL.Text,
+        'keywords': IDL.Vec(IDL.Text),
+        'donation': IDL.Text,
+        'devDependencies': IDL.Vec(DependencyV2),
+        'repository': IDL.Text,
+        'dependencies': IDL.Vec(DependencyV2),
+        'license': IDL.Text,
+        'readme': IDL.Text,
+    });
+    const PublishingErr = IDL.Text;
+    const Result_1 = IDL.Variant({ 'ok': PublishingId, 'err': PublishingErr });
+    const TestStats = IDL.Record({
+        'passedNames': IDL.Vec(IDL.Text),
+        'passed': IDL.Nat,
+    });
+    return IDL.Service({
+        'backup': IDL.Func([], [], []),
+        'claimAirdrop': IDL.Func([IDL.Principal], [IDL.Text], []),
+        'diff': IDL.Func([IDL.Text, IDL.Text], [PackageChanges__1], ['query']),
+        'finishPublish': IDL.Func([PublishingId], [Result], []),
+        'getAirdropAmount': IDL.Func([], [IDL.Nat], ['query']),
+        'getAirdropAmountAll': IDL.Func([], [IDL.Nat], ['query']),
+        'getApiVersion': IDL.Func([], [Text], ['query']),
+        'getBackupCanisterId': IDL.Func([], [IDL.Principal], ['query']),
+        'getDefaultPackages': IDL.Func([IDL.Text], [IDL.Vec(IDL.Tuple(PackageName__1, PackageVersion))], ['query']),
+        'getDownloadTrendByPackageId': IDL.Func([PackageId], [IDL.Vec(DownloadsSnapshot__1)], ['query']),
+        'getDownloadTrendByPackageName': IDL.Func([PackageName__1], [IDL.Vec(DownloadsSnapshot__1)], ['query']),
+        'getFileIds': IDL.Func([PackageName__1, PackageVersion], [Result_7], ['query']),
+        'getHighestSemverBatch': IDL.Func([IDL.Vec(IDL.Tuple(PackageName__1, PackageVersion, SemverPart))], [Result_6], ['query']),
+        'getHighestVersion': IDL.Func([PackageName__1], [Result_5], ['query']),
+        'getMostDownloadedPackages': IDL.Func([], [IDL.Vec(PackageSummary)], ['query']),
+        'getMostDownloadedPackagesIn7Days': IDL.Func([], [IDL.Vec(PackageSummary)], ['query']),
+        'getNewPackages': IDL.Func([], [IDL.Vec(PackageSummary)], ['query']),
+        'getPackageDetails': IDL.Func([PackageName__1, PackageVersion], [Result_4], ['query']),
+        'getPackagesByCategory': IDL.Func([], [IDL.Vec(IDL.Tuple(IDL.Text, IDL.Vec(PackageSummary)))], ['query']),
+        'getRecentlyUpdatedPackages': IDL.Func([], [IDL.Vec(PackageSummaryWithChanges)], ['query']),
+        'getStoragesStats': IDL.Func([], [IDL.Vec(IDL.Tuple(StorageId, StorageStats))], ['query']),
+        'getTotalDownloads': IDL.Func([], [IDL.Nat], ['query']),
+        'getTotalPackages': IDL.Func([], [IDL.Nat], ['query']),
+        'getUser': IDL.Func([IDL.Principal], [IDL.Opt(User__1)], ['query']),
+        'notifyInstall': IDL.Func([PackageName__1, PackageVersion], [], ['oneway']),
+        'notifyInstalls': IDL.Func([IDL.Vec(IDL.Tuple(PackageName__1, PackageVersion))], [], ['oneway']),
+        'restore': IDL.Func([IDL.Nat, IDL.Nat], [], []),
+        'search': IDL.Func([Text, IDL.Opt(IDL.Nat), IDL.Opt(IDL.Nat)], [IDL.Vec(PackageSummary), PageCount], ['query']),
+        'setUserProp': IDL.Func([IDL.Text, IDL.Text], [Result_3], []),
+        'startFileUpload': IDL.Func([PublishingId, Text, IDL.Nat, IDL.Vec(IDL.Nat8)], [Result_2], []),
+        'startPublish': IDL.Func([PackageConfigV2], [Result_1], []),
+        'takeAirdropSnapshot': IDL.Func([], [], ['oneway']),
+        'uploadFileChunk': IDL.Func([PublishingId, FileId, IDL.Nat, IDL.Vec(IDL.Nat8)], [Result], []),
+        'uploadNotes': IDL.Func([PublishingId, IDL.Text], [Result], []),
+        'uploadTestStats': IDL.Func([PublishingId, TestStats], [Result], []),
+    });
+};
+export const init = ({ IDL }) => { return []; };

package/dist/commands/bench/declarations/storage/index.d.ts

@@ -0,0 +1,4 @@
+export function createActor(canisterId: string | import("@dfinity/principal").Principal, options?: {
+    agentOptions?: import("@dfinity/agent").HttpAgentOptions;
+    actorOptions?: import("@dfinity/agent").ActorConfig;
+} | undefined): import("@dfinity/agent").ActorSubclass<import("./storage.did.js")._SERVICE>;

package/dist/commands/bench/declarations/storage/index.js

@@ -0,0 +1,26 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+// Imports and re-exports candid interface
+import { idlFactory } from './storage.did.js';
+export { idlFactory } from './storage.did.js';
+/**
+ *
+ * @param {string | import("@dfinity/principal").Principal} canisterId Canister ID of Agent
+ * @param {{agentOptions?: import("@dfinity/agent").HttpAgentOptions; actorOptions?: import("@dfinity/agent").ActorConfig}} [options]
+ * @return {import("@dfinity/agent").ActorSubclass<import("./storage.did.js")._SERVICE>}
+ */
+export const createActor = (canisterId, options) => {
+    const agent = new HttpAgent({ ...options?.agentOptions });
+    // Fetch root key for certificate validation during development
+    if (process.env.NODE_ENV !== "production") {
+        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/commands/bench/declarations/storage/storage.did.d.ts

@@ -0,0 +1,6 @@
+export function idlFactory({ IDL }: {
+    IDL: any;
+}): any;
+export function init({ IDL }: {
+    IDL: any;
+}): never[];

package/dist/commands/bench/declarations/storage/storage.did.js

@@ -0,0 +1,34 @@
+export const idlFactory = ({ IDL }) => {
+    const FileId = IDL.Text;
+    const Chunk = IDL.Vec(IDL.Nat8);
+    const Err = IDL.Text;
+    const Result_2 = IDL.Variant({ 'ok': Chunk, 'err': Err });
+    const FileId__1 = IDL.Text;
+    const FileMeta = IDL.Record({
+        'id': FileId__1,
+        'owners': IDL.Vec(IDL.Principal),
+        'path': IDL.Text,
+        'chunkCount': IDL.Nat,
+    });
+    const Result_1 = IDL.Variant({ 'ok': FileMeta, 'err': Err });
+    const StorageStats = IDL.Record({
+        'fileCount': IDL.Nat,
+        'cyclesBalance': IDL.Nat,
+        'memorySize': IDL.Nat,
+    });
+    const Result = IDL.Variant({ 'ok': IDL.Null, 'err': Err });
+    const Storage = IDL.Service({
+        'acceptCycles': IDL.Func([], [], []),
+        'deleteFile': IDL.Func([FileId], [], []),
+        'downloadChunk': IDL.Func([FileId, IDL.Nat], [Result_2], ['query']),
+        'finishUpload': IDL.Func([FileId], [], []),
+        'getFileIdsRange': IDL.Func([IDL.Nat, IDL.Nat], [IDL.Vec(FileId)], ['query']),
+        'getFileMeta': IDL.Func([FileId], [Result_1], ['query']),
+        'getStats': IDL.Func([], [StorageStats], ['query']),
+        'startUpload': IDL.Func([FileMeta], [Result], []),
+        'updateFileOwners': IDL.Func([FileId, IDL.Vec(IDL.Principal)], [], []),
+        'uploadChunk': IDL.Func([FileId, IDL.Nat, Chunk], [], []),
+    });
+    return Storage;
+};
+export const init = ({ IDL }) => { return []; };

package/dist/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/dist/commands/bench.d.ts

@@ -0,0 +1,10 @@
+type BenchOptions = {
+    verbose?: boolean;
+    save?: boolean;
+    compare?: boolean;
+    dfx?: string;
+    moc?: string;
+    gc?: 'copying' | 'compacting' | 'generational' | 'incremental' | 'none';
+};
+export declare function bench(filter?: string, options?: BenchOptions): Promise<boolean>;
+export {};

package/dist/commands/bench.js

@@ -0,0 +1,214 @@
+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 { absToRel } from './test/utils.js';
+import { getMocVersion } from '../helpers/get-moc-version.js';
+import { getDfxVersion } from '../helpers/get-dfx-version.js';
+let ignore = [
+    '**/node_modules/**',
+    '**/.mops/**',
+    '**/.vessel/**',
+    '**/.git/**',
+];
+let globConfig = {
+    nocase: true,
+    ignore: ignore,
+};
+export async function bench(filter = '', 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 files 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('Starting dfx replica...');
+    startDfx(options.verbose);
+    let resultsByName = new Map();
+    // await parallel(os.cpus().length, files, async (file: string) => {
+    await parallel(1, files, async (file) => {
+        console.log('\n' + '—'.repeat(50));
+        console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
+        console.log('');
+        try {
+            let { schema, results } = await runBenchFile(file, options);
+            resultsByName.set(schema.name || absToRel(file), results);
+        }
+        catch (err) {
+            console.error('Unexpected error. Stopping dfx replica...');
+            stopDfx(options.verbose);
+            throw err;
+        }
+    });
+    if (options.save) {
+        console.log('Saving results to mops.bench.json...');
+        let json = {
+            version: 1,
+            moc: options.moc || getMocVersion(),
+            dfx: options.dfx || getDfxVersion(),
+            gc: options.gc || 'incremental',
+            results: {},
+        };
+        resultsByName.forEach((results, name) => {
+            json.results[name] = Array.from(results.entries());
+        });
+        fs.writeFileSync(path.join(rootDir, 'mops.bench.json'), JSON.stringify(json, (_, val) => {
+            if (typeof val === 'bigint') {
+                return Number(val);
+            }
+            else {
+                return val;
+            }
+        }, 2));
+    }
+    console.log('Stopping dfx replica...');
+    stopDfx(options.verbose);
+    fs.rmSync(benchDir, { recursive: true, force: true });
+    return true;
+}
+function dfxJson(canisterName) {
+    return {
+        version: 1,
+        canisters: {
+            [canisterName]: {
+                type: 'motoko',
+                main: 'canister.mo',
+                args: '--force-gc --incremental-gc',
+            }
+        },
+        defaults: {
+            build: {
+                packtool: 'mops sources',
+            },
+        },
+        networks: {
+            local: {
+                type: 'ephemeral',
+                bind: '127.0.0.1:4947',
+            },
+        },
+    };
+}
+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', { cwd: dir, stdio: ['inherit', verbose ? 'inherit' : 'ignore', 'inherit'] });
+}
+function stopDfx(verbose = false) {
+    let dir = path.join(getRootDir(), '.mops/.bench');
+    execSync('dfx stop', { cwd: dir, stdio: ['pipe', verbose ? 'inherit' : 'ignore', 'pipe'] });
+}
+async function runBenchFile(file, options = {}) {
+    let rootDir = getRootDir();
+    let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
+    fs.mkdirSync(tempDir, { recursive: true });
+    let canisterName = Date.now().toString(36);
+    // prepare temp files
+    fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(dfxJson(canisterName), 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'));
+    // deploy canister
+    execSync(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+    let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
+    let actor = await createActor(canisterId, {
+        agentOptions: {
+            host: 'http://127.0.0.1:4947',
+        },
+    });
+    let schema = await actor.init();
+    // load previous results
+    let prevResults;
+    if (options.compare) {
+        let prevResultsJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'mops.bench.json')).toString());
+        if (prevResultsJson.results[schema.name]) {
+            prevResults = new Map(prevResultsJson.results[schema.name]);
+        }
+        else {
+            console.log(chalk.yellow(`No previous results found for benchmark with name "${schema.name}"`));
+        }
+    }
+    let results = new Map();
+    let formatNumber = (n) => {
+        return n.toLocaleString('en-US').replaceAll(',', '_');
+    };
+    let getTable = (prop) => {
+        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));
+            results.set(`${row}:${col}`, res);
+            printResults();
+        }
+    }
+    logUpdate.done();
+    return { schema, results };
+}

package/dist/commands/init.js

@@ -146,15 +146,22 @@ async function applyInit({ type, config, setupWorkflow, addTest, copyrightOwner
     let dfxJsonData;
     if (existsSync(dfxJson)) {
         let dfxJsonText = readFileSync(dfxJson).toString();
-        dfxJsonData = JSON.parse(dfxJsonText);
-        console.log('Setting packtool in dfx.json...');
-        dfxJsonData.defaults = dfxJsonData.defaults || {};
-        dfxJsonData.defaults.build = dfxJsonData.defaults.build || {};
-        if (dfxJsonData.defaults.build.packtool !== 'mops sources') {
-            dfxJsonData.defaults.build.packtool = 'mops sources';
-            let indent = dfxJsonText.match(/([ \t]+)"/)?.[1] || '  ';
-            writeFileSync(path.join(process.cwd(), 'dfx.json'), JSON.stringify(dfxJsonData, null, indent));
-            console.log(chalk.green('packtool set to "mops sources"'));
+        try {
+            dfxJsonData = JSON.parse(dfxJsonText);
+        }
+        catch (err) {
+            console.log(chalk.yellow('Failed to parse dfx.json'));
+        }
+        if (dfxJsonData) {
+            console.log('Setting packtool in dfx.json...');
+            dfxJsonData.defaults = dfxJsonData.defaults || {};
+            dfxJsonData.defaults.build = dfxJsonData.defaults.build || {};
+            if (dfxJsonData.defaults.build.packtool !== 'mops sources') {
+                dfxJsonData.defaults.build.packtool = 'mops sources';
+                let indent = dfxJsonText.match(/([ \t]+)"/)?.[1] || '  ';
+                writeFileSync(path.join(process.cwd(), 'dfx.json'), JSON.stringify(dfxJsonData, null, indent));
+                console.log(chalk.green('packtool set to "mops sources"'));
+            }
         }
     }
     // get default packages

package/dist/declarations/bench/bench.did

@@ -0,0 +1,24 @@
+type anon_class_10_1 = 
+ service {
+   getStats: () -> (BenchResult) query;
+   init: () -> (BenchSchema);
+   runCellQuery: (nat, nat) -> (BenchResult) query;
+   runCellUpdate: (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/dist/declarations/bench/bench.did.d.ts

@@ -0,0 +1,24 @@
+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 {
+  'getStats' : ActorMethod<[], BenchResult>,
+  'init' : ActorMethod<[], BenchSchema>,
+  'runCellQuery' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdate' : ActorMethod<[bigint, bigint], BenchResult>,
+}
+export interface _SERVICE extends anon_class_10_1 {}

package/dist/declarations/bench/bench.did.js

@@ -0,0 +1,24 @@
+export const idlFactory = ({ IDL }) => {
+  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 BenchSchema = IDL.Record({
+    'cols' : IDL.Vec(IDL.Text),
+    'name' : IDL.Text,
+    'rows' : IDL.Vec(IDL.Text),
+    'description' : IDL.Text,
+  });
+  const anon_class_10_1 = IDL.Service({
+    '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], []),
+  });
+  return anon_class_10_1;
+};
+export const init = ({ IDL }) => { return []; };