ic-mops 1.11.1 → 2.0.0

package/dist/commands/add.d.ts

@@ -1,7 +1,7 @@
 type AddOptions = {
     verbose?: boolean;
     dev?: boolean;
-    lock?: 'update' | 'ignore';
+    lock?: "update" | "ignore";
 };
 export declare function add(name: string, { verbose, dev, lock }?: AddOptions, asName?: string): Promise<void>;
 export {};

package/dist/commands/add.js

@@ -1,16 +1,16 @@
-import process from 'node:process';
-import path from 'node:path';
-import chalk from 'chalk';
-import { createLogUpdate } from 'log-update';
-import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig, writeConfig } from '../mops.js';
-import { getHighestVersion } from '../api/getHighestVersion.js';
-import { installMopsDep } from './install/install-mops-dep.js';
-import { installFromGithub } from '../vessel.js';
-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';
+import process from "node:process";
+import path from "node:path";
+import chalk from "chalk";
+import { createLogUpdate } from "log-update";
+import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig, writeConfig, } from "../mops.js";
+import { getHighestVersion } from "../api/getHighestVersion.js";
+import { installMopsDep } from "./install/install-mops-dep.js";
+import { installFromGithub } from "../vessel.js";
+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";
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function add(name, { verbose = false, dev = false, lock } = {}, asName) {
     if (!checkConfigFile()) {
@@ -18,8 +18,8 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
     }
     let config = readConfig();
     if (dev) {
-        if (!config['dev-dependencies']) {
-            config['dev-dependencies'] = {};
+        if (!config["dev-dependencies"]) {
+            config["dev-dependencies"] = {};
         }
     }
     else {
@@ -29,16 +29,17 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
     }
     let pkgDetails;
     // local package
-    if (name.startsWith('./') || name.startsWith('../') || name.startsWith('/')) {
+    if (name.startsWith("./") || name.startsWith("../") || name.startsWith("/")) {
         pkgDetails = {
-            name: path.parse(name).name === '.' ? '_' : path.parse(name).name,
+            name: path.parse(name).name === "." ? "_" : path.parse(name).name,
             path: name,
-            repo: '',
-            version: '',
+            repo: "",
+            version: "",
         };
     }
     // github package
-    else if (name.startsWith('https://github.com') || name.split('/').length > 1) {
+    else if (name.startsWith("https://github.com") ||
+        name.split("/").length > 1) {
         let { org, gitName, branch, commitHash } = parseGithubURL(name);
         // fetch latest commit hash of branch if not specified
         if (!commitHash) {
@@ -51,40 +52,44 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
         pkgDetails = {
             name: asName || parseGithubURL(name).gitName,
             repo: `https://github.com/${org}/${gitName}#${branch}@${commitHash}`,
-            version: '',
+            version: "",
         };
     }
     // mops package
     else {
         let ver;
-        if (name.includes('@')) {
+        if (name.includes("@")) {
             // @ts-ignore
-            [name, ver] = name.split('@');
+            [name, ver] = name.split("@");
         }
         else {
             let versionRes = await getHighestVersion(name);
-            if ('err' in versionRes) {
-                console.log(chalk.red('Error: ') + versionRes.err);
+            if ("err" in versionRes) {
+                console.log(chalk.red("Error: ") + versionRes.err);
                 return;
             }
             ver = versionRes.ok;
         }
         pkgDetails = {
-            name: name,
-            repo: '',
+            name: asName || name,
+            repo: "",
             version: ver,
         };
     }
     if (pkgDetails.repo) {
-        await installFromGithub(pkgDetails.name, pkgDetails.repo, { verbose: verbose });
+        await installFromGithub(pkgDetails.name, pkgDetails.repo, {
+            verbose: verbose,
+        });
     }
     else if (!pkgDetails.path) {
-        let res = await installMopsDep(pkgDetails.name, pkgDetails.version, { verbose: verbose });
+        let res = await installMopsDep(pkgDetails.name, pkgDetails.version, {
+            verbose: verbose,
+        });
         if (res === false) {
             return;
         }
     }
-    const depsProp = dev ? 'dev-dependencies' : 'dependencies';
+    const depsProp = dev ? "dev-dependencies" : "dependencies";
     let deps = config[depsProp];
     if (deps) {
         deps[pkgDetails.name] = pkgDetails;
@@ -94,17 +99,15 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
     }
     writeConfig(config);
     let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
-    if (lock !== 'ignore') {
-        logUpdate('Checking integrity...');
+    if (lock !== "ignore") {
+        logUpdate("Checking integrity...");
     }
     let installedPackages = await syncLocalCache();
-    await Promise.all([
-        notifyInstalls(installedPackages),
-        checkIntegrity(lock),
-    ]);
+    await Promise.all([notifyInstalls(installedPackages), checkIntegrity(lock)]);
     logUpdate.clear();
     await checkRequirements({ verbose });
-    console.log(chalk.green('Package installed ') + `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);
+    console.log(chalk.green("Package installed ") +
+        `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);
     // check conflicts
-    await resolvePackages({ conflicts: 'warning' });
+    await resolvePackages({ conflicts: "warning" });
 }

package/dist/commands/available-updates.d.ts

@@ -1,2 +1,2 @@
-import { Config } from '../types.js';
+import { Config } from "../types.js";
 export declare function getAvailableUpdates(config: Config, pkg?: string): Promise<Array<[string, string, string]>>;

package/dist/commands/available-updates.js

@@ -1,28 +1,46 @@
-import process from 'node:process';
-import chalk from 'chalk';
-import { mainActor } from '../api/actors.js';
-import { getDepName } from '../helpers/get-dep-name.js';
+import process from "node:process";
+import chalk from "chalk";
+import { mainActor } from "../api/actors.js";
+import { getDepName, getDepPinnedVersion } from "../helpers/get-dep-name.js";
 // [pkg, oldVersion, newVersion]
 export async function getAvailableUpdates(config, pkg) {
     let deps = Object.values(config.dependencies || {});
-    let devDeps = Object.values(config['dev-dependencies'] || {});
+    let devDeps = Object.values(config["dev-dependencies"] || {});
     let allDeps = [...deps, ...devDeps].filter((dep) => dep.version);
     let depsToUpdate = pkg ? allDeps.filter((dep) => dep.name === pkg) : allDeps;
-    // skip pinned dependencies
-    depsToUpdate = depsToUpdate.filter((dep) => getDepName(dep.name) === dep.name);
-    let getCurrentVersion = (pkg) => {
+    // skip hard pinned dependencies (e.g. "base@X.Y.Z")
+    depsToUpdate = depsToUpdate.filter((dep) => getDepName(dep.name) === dep.name ||
+        getDepPinnedVersion(dep.name).split(".").length !== 3);
+    let getCurrentVersion = (pkg, updateVersion) => {
         for (let dep of allDeps) {
-            if (dep.name === pkg && dep.version) {
+            if (getDepName(dep.name) === pkg && dep.version) {
+                let pinnedVersion = getDepPinnedVersion(dep.name);
+                if (pinnedVersion && !updateVersion.startsWith(pinnedVersion)) {
+                    continue;
+                }
                 return dep.version;
             }
         }
-        return '';
+        return "";
     };
     let actor = await mainActor();
-    let res = await actor.getHighestSemverBatch(depsToUpdate.map((dep) => [dep.name, dep.version || '', { major: null }]));
-    if ('err' in res) {
-        console.log(chalk.red('Error:'), res.err);
+    let res = await actor.getHighestSemverBatch(depsToUpdate.map((dep) => {
+        let semverPart = { major: null };
+        let name = getDepName(dep.name);
+        let pinnedVersion = getDepPinnedVersion(dep.name);
+        if (pinnedVersion) {
+            semverPart =
+                pinnedVersion.split(".").length === 1
+                    ? { minor: null }
+                    : { patch: null };
+        }
+        return [name, dep.version || "", semverPart];
+    }));
+    if ("err" in res) {
+        console.log(chalk.red("Error:"), res.err);
         process.exit(1);
     }
-    return res.ok.filter((dep) => dep[1] !== getCurrentVersion(dep[0])).map((dep) => [dep[0], getCurrentVersion(dep[0]), dep[1]]);
+    return res.ok
+        .filter((dep) => dep[1] !== getCurrentVersion(dep[0], dep[1]))
+        .map((dep) => [dep[0], getCurrentVersion(dep[0], dep[1]), dep[1]]);
 }

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

@@ -1,113 +1,119 @@
-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 Nat64 "mo:core/Nat64";
+import Nat "mo:core/Nat";
+import Runtime "mo:core/Runtime";
+import InternetComputer "mo:core/InternetComputer";
+import Int64 "mo:core/Int64";
+import Region "mo:core/Region";
 import Prim "mo:prim";
 import Bench "mo:bench";
 
 import UserBench "./user-bench"; // file path will be replaced with the *.bench.mo file path
 
-persistent 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;
-	};
-
-	transient 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();
-	};
-
-	public query func getSchema() : async Bench.BenchSchema {
-		let ?bench = benchOpt else Debug.trap("bench not initialized");
-		bench.getSchema();
-	};
-
-	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 : 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) : 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 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 BenchResult {
-		_getStats();
-	};
-
-	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		_runCell(rowIndex, colIndex);
-	};
-
-	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		_runCell(rowIndex, colIndex);
-	};
-
-	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		await _runCellAwait(rowIndex, colIndex);
-	};
-};
+persistent 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;
+  };
+
+  transient var benchOpt : ?Bench.Bench = null;
+
+  public func init() : async Bench.BenchSchema {
+    let bench = UserBench.init();
+    benchOpt := ?bench;
+    ignore Region.grow(Region.new(), 1);
+    bench.getSchema();
+  };
+
+  public query func getSchema() : async Bench.BenchSchema {
+    let ?bench = benchOpt else Runtime.trap("bench not initialized");
+    bench.getSchema();
+  };
+
+  func _getStats() : BenchResult {
+    {
+      instructions = 0;
+      rts_heap_size = Prim.rts_heap_size();
+      stable_memory_size = Int64.toInt(Int64.fromNat64(Prim.stableMemorySize())) * 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 : 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) : BenchResult {
+    let ?bench = benchOpt else Runtime.trap("bench not initialized");
+    let statsBefore = _getStats();
+
+    let instructions = Nat64.toNat(
+      InternetComputer.countInstructions(
+        func() {
+          bench.runCell(rowIndex, colIndex);
+        }
+      )
+    );
+
+    let statsAfter = _getStats();
+    _diffStats(statsBefore, { statsAfter with instructions });
+  };
+
+  func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    let ?bench = benchOpt else Runtime.trap("bench not initialized");
+    let statsBefore = _getStats();
+
+    let instructions = Nat64.toNat(
+      InternetComputer.countInstructions(
+        func() {
+          bench.runCell(rowIndex, colIndex);
+        }
+      )
+    );
+
+    await (func() : async () {})();
+
+    let statsAfter = _getStats();
+    _diffStats(statsBefore, { statsAfter with instructions });
+  };
+
+  public query func getStats() : async BenchResult {
+    _getStats();
+  };
+
+  public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    _runCell(rowIndex, colIndex);
+  };
+
+  public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    _runCell(rowIndex, colIndex);
+  };
+
+  public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    await _runCellAwait(rowIndex, colIndex);
+  };
+};

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

@@ -2,9 +2,9 @@ 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;
-	};
-};
+  public func init() : Bench.Bench {
+    let bench = Bench.Bench();
+    // benchmark code goes here...
+    bench;
+  };
+};

package/dist/commands/bench-replica.d.ts

@@ -1,15 +1,16 @@
-import { PocketIc, PocketIcServer } from 'pic-ic';
+import { PocketIc, PocketIcServer } from "pic-ic";
+import { PocketIc as PocketIcMops, PocketIcServer as PocketIcServerMops } from "pic-js-mops";
 export declare class BenchReplica {
-    type: 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
+    type: "dfx" | "pocket-ic" | "dfx-pocket-ic";
     verbose: boolean;
     canisters: Record<string, {
         cwd: string;
         canisterId: string;
         actor: any;
     }>;
-    pocketIcServer?: PocketIcServer;
-    pocketIc?: PocketIc;
-    constructor(type: 'dfx' | 'pocket-ic' | 'dfx-pocket-ic', verbose?: boolean);
+    pocketIcServer?: PocketIcServer | PocketIcServerMops;
+    pocketIc?: PocketIc | PocketIcMops;
+    constructor(type: "dfx" | "pocket-ic" | "dfx-pocket-ic", verbose?: boolean);
     start({ silent }?: {
         silent?: boolean | undefined;
     }): Promise<void>;

package/dist/commands/bench-replica.js

@@ -1,13 +1,14 @@
-import process from 'node:process';
-import { execSync } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import { execaCommand } from 'execa';
-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';
-import { getDfxVersion } from '../helpers/get-dfx-version.js';
+import process from "node:process";
+import { execSync } from "node:child_process";
+import path from "node:path";
+import fs from "node:fs";
+import { execaCommand } from "execa";
+import { PocketIc, PocketIcServer } from "pic-ic";
+import { PocketIc as PocketIcMops, PocketIcServer as PocketIcServerMops, } from "pic-js-mops";
+import { getRootDir, readConfig } from "../mops.js";
+import { createActor, idlFactory } from "../declarations/bench/index.js";
+import { toolchain } from "./toolchain/index.js";
+import { getDfxVersion } from "../helpers/get-dfx-version.js";
 export class BenchReplica {
     type;
     verbose = false;
@@ -22,29 +23,48 @@ export class BenchReplica {
         if (!process.env.CI && !silent) {
             console.log(`Starting ${this.type} replica...`);
         }
-        if (this.type == 'dfx' || this.type === 'dfx-pocket-ic') {
+        if (this.type == "dfx" || this.type === "dfx-pocket-ic") {
             await this.stop();
-            let dir = path.join(getRootDir(), '.mops/.bench');
-            fs.writeFileSync(path.join(dir, 'dfx.json'), JSON.stringify(this.dfxJson(''), null, 2));
-            execSync('dfx start --background --clean --artificial-delay 0' + (this.type === 'dfx-pocket-ic' ? ' --pocketic' : '') + (this.verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['inherit', this.verbose ? 'inherit' : 'ignore', 'inherit'] });
+            let dir = path.join(getRootDir(), ".mops/.bench");
+            fs.writeFileSync(path.join(dir, "dfx.json"), JSON.stringify(this.dfxJson(""), null, 2));
+            execSync("dfx start --background --clean --artificial-delay 0" +
+                (this.type === "dfx-pocket-ic" ? " --pocketic" : "") +
+                (this.verbose ? "" : " -qqqq"), {
+                cwd: dir,
+                stdio: ["inherit", this.verbose ? "inherit" : "ignore", "inherit"],
+            });
         }
         else {
-            let pocketIcBin = await toolchain.bin('pocket-ic');
+            let pocketIcBin = await toolchain.bin("pocket-ic");
             let config = readConfig();
-            if (config.toolchain?.['pocket-ic'] !== '4.0.0') {
-                console.error('Current Mops CLI only supports pocket-ic 4.0.0');
+            if (config.toolchain?.["pocket-ic"] !== "4.0.0" &&
+                !config.toolchain?.["pocket-ic"]?.startsWith("9.")) {
+                console.error("Current Mops CLI only supports pocket-ic 9.x.x and 4.0.0");
                 process.exit(1);
             }
-            this.pocketIcServer = await PocketIcServer.start({
-                binPath: pocketIcBin,
-            });
-            this.pocketIc = await PocketIc.create(this.pocketIcServer.getUrl());
+            // pocket-ic 9.x.x
+            if (config.toolchain?.["pocket-ic"]?.startsWith("9.")) {
+                this.pocketIcServer = await PocketIcServerMops.start({
+                    binPath: pocketIcBin,
+                });
+                this.pocketIc = await PocketIcMops.create(this.pocketIcServer.getUrl());
+            }
+            // pocket-ic 4.0.0
+            else {
+                this.pocketIcServer = await PocketIcServer.start({
+                    binPath: pocketIcBin,
+                });
+                this.pocketIc = await PocketIc.create(this.pocketIcServer.getUrl());
+            }
         }
     }
     async stop() {
-        if (this.type == 'dfx' || this.type === 'dfx-pocket-ic') {
-            let dir = path.join(getRootDir(), '.mops/.bench');
-            execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe'] });
+        if (this.type == "dfx" || this.type === "dfx-pocket-ic") {
+            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 && this.pocketIcServer) {
             await this.pocketIc.tearDown();
@@ -52,12 +72,14 @@ export class BenchReplica {
         }
     }
     async deploy(name, wasm, cwd = process.cwd()) {
-        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
-            await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, { cwd, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
-            let canisterId = execSync(`dfx canister id ${name}`, { cwd }).toString().trim();
+        if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
+            await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, { cwd, stdio: this.verbose ? "pipe" : ["pipe", "ignore", "pipe"] });
+            let canisterId = execSync(`dfx canister id ${name}`, { cwd })
+                .toString()
+                .trim();
             let actor = await createActor(canisterId, {
                 agentOptions: {
-                    host: 'http://127.0.0.1:4944',
+                    host: "http://127.0.0.1:4944",
                 },
             });
             this.canisters[name] = { cwd, canisterId, actor };
@@ -75,16 +97,16 @@ export class BenchReplica {
         return this.canisters[name]?.actor;
     }
     getCanisterId(name) {
-        return this.canisters[name]?.canisterId || '';
+        return this.canisters[name]?.canisterId || "";
     }
     dfxJson(canisterName) {
         let canisters = {};
         if (canisterName) {
             canisters[canisterName] = {
-                type: 'custom',
-                wasm: 'canister.wasm',
-                candid: 'canister.did',
-                optimize: 'cycles',
+                type: "custom",
+                wasm: "canister.wasm",
+                candid: "canister.did",
+                optimize: "cycles",
             };
         }
         return {
@@ -93,13 +115,13 @@ export class BenchReplica {
             dfx: getDfxVersion(),
             defaults: {
                 build: {
-                    packtool: 'mops sources',
+                    packtool: "mops sources",
                 },
             },
             networks: {
                 local: {
-                    type: 'ephemeral',
-                    bind: '127.0.0.1:4944',
+                    type: "ephemeral",
+                    bind: "127.0.0.1:4944",
                 },
             },
         };