ic-mops 2.3.1 → 2.4.0

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

@@ -1,5 +1,4 @@
-import { PocketIc, PocketIcServer } from "pic-ic";
-import { PocketIc as PocketIcMops, PocketIcServer as PocketIcServerMops } from "pic-js-mops";
+import { type AnyPocketIcServer, type AnyPocketIc } from "../helpers/pocket-ic-client.js";
 export declare class BenchReplica {
     type: "dfx" | "pocket-ic" | "dfx-pocket-ic";
     verbose: boolean;
@@ -8,8 +7,8 @@ export declare class BenchReplica {
         canisterId: string;
         actor: any;
     }>;
-    pocketIcServer?: PocketIcServer | PocketIcServerMops;
-    pocketIc?: PocketIc | PocketIcMops;
+    pocketIcServer?: AnyPocketIcServer;
+    pocketIc?: AnyPocketIc;
     constructor(type: "dfx" | "pocket-ic" | "dfx-pocket-ic", verbose?: boolean);
     start({ silent }?: {
         silent?: boolean | undefined;

package/dist/commands/bench-replica.js

@@ -3,9 +3,8 @@ 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 { getRootDir } from "../mops.js";
+import { startPocketIc, } from "../helpers/pocket-ic-client.js";
 import { createActor, idlFactory } from "../declarations/bench/index.js";
 import { toolchain } from "./toolchain/index.js";
 import { getDfxVersion } from "../helpers/get-dfx-version.js";
@@ -36,26 +35,9 @@ export class BenchReplica {
         }
         else {
             let pocketIcBin = await toolchain.bin("pocket-ic");
-            let config = readConfig();
-            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);
-            }
-            // 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());
-            }
+            let pic = await startPocketIc({ binPath: pocketIcBin });
+            this.pocketIcServer = pic.server;
+            this.pocketIc = pic.client;
         }
     }
     async stop() {

package/dist/commands/build.js

@@ -7,7 +7,7 @@ import { cliError } from "../error.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
 import { resolveCanisterConfigs } from "../helpers/resolve-canisters.js";
 import { getWasmBindings } from "../wasm.js";
-import { getGlobalMocArgs, readConfig } from "../mops.js";
+import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 export const DEFAULT_BUILD_OUTPUT_DIR = ".mops/.build";
@@ -15,9 +15,12 @@ export async function build(canisterNames, options) {
     if (canisterNames?.length == 0) {
         cliError("No canisters specified to build");
     }
-    let outputDir = options.outputDir ?? DEFAULT_BUILD_OUTPUT_DIR;
-    let mocPath = await toolchain.bin("moc", { fallback: true });
     let config = readConfig();
+    let configOutputDir = config.build?.outputDir
+        ? resolveConfigPath(config.build.outputDir)
+        : undefined;
+    let outputDir = options.outputDir ?? configOutputDir ?? DEFAULT_BUILD_OUTPUT_DIR;
+    let mocPath = await toolchain.bin("moc", { fallback: true });
     let canisters = resolveCanisterConfigs(config);
     if (!Object.keys(canisters).length) {
         cliError(`No Motoko canisters found in mops.toml configuration`);
@@ -45,6 +48,7 @@ export async function build(canisterNames, options) {
         if (!motokoPath) {
             cliError(`No main file is specified for canister ${canisterName}`);
         }
+        motokoPath = resolveConfigPath(motokoPath);
         const wasmPath = join(outputDir, `${canisterName}.wasm`);
         let args = [
             "-c",
@@ -55,19 +59,7 @@ export async function build(canisterNames, options) {
             ...(await sourcesArgs()).flat(),
             ...getGlobalMocArgs(config),
         ];
-        if (config.build?.args) {
-            if (typeof config.build.args === "string") {
-                cliError(`[build] config 'args' should be an array of strings in mops.toml config file`);
-            }
-            args.push(...config.build.args);
-        }
-        if (canister.args) {
-            if (typeof canister.args === "string") {
-                cliError(`Canister config 'args' should be an array of strings for canister ${canisterName}`);
-            }
-            args.push(...canister.args);
-        }
-        args.push(...(options.extraArgs ?? []));
+        args.push(...collectExtraArgs(config, canister, canisterName, options.extraArgs));
         const isPublicCandid = true; // always true for now to reduce corner cases
         const candidVisibility = isPublicCandid ? "icp:public" : "icp:private";
         if (isPublicCandid) {
@@ -98,10 +90,12 @@ export async function build(canisterNames, options) {
                 console.log(result.stdout);
             }
             const generatedDidPath = join(outputDir, `${canisterName}.did`);
-            if (canister.candid) {
-                const originalCandidPath = canister.candid;
+            const resolvedCandidPath = canister.candid
+                ? resolveConfigPath(canister.candid)
+                : null;
+            if (resolvedCandidPath) {
                 try {
-                    const compatible = await isCandidCompatible(generatedDidPath, originalCandidPath);
+                    const compatible = await isCandidCompatible(generatedDidPath, resolvedCandidPath);
                     if (!compatible) {
                         cliError(`Candid compatibility check failed for canister ${canisterName}`);
                     }
@@ -115,7 +109,7 @@ export async function build(canisterNames, options) {
             }
             options.verbose &&
                 console.log(chalk.gray(`Adding metadata to ${wasmPath}`));
-            const candidPath = canister.candid ?? generatedDidPath;
+            const candidPath = resolvedCandidPath ?? generatedDidPath;
             const candidText = await readFile(candidPath, "utf-8");
             const customSections = [
                 { name: `${candidVisibility} candid:service`, data: candidText },
@@ -139,3 +133,36 @@ export async function build(canisterNames, options) {
     }
     console.log(chalk.green(`\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length == 1 ? "" : "s"} successfully`));
 }
+const managedFlags = {
+    "-o": "use [build].outputDir in mops.toml or --output flag instead",
+    "-c": "this flag is always set by mops build",
+    "--idl": "this flag is always set by mops build",
+    "--public-metadata": "this flag is managed by mops build",
+};
+function collectExtraArgs(config, canister, canisterName, extraArgs) {
+    const args = [];
+    if (config.build?.args) {
+        if (typeof config.build.args === "string") {
+            cliError(`[build] config 'args' should be an array of strings in mops.toml config file`);
+        }
+        args.push(...config.build.args);
+    }
+    if (canister.args) {
+        if (typeof canister.args === "string") {
+            cliError(`Canister config 'args' should be an array of strings for canister ${canisterName}`);
+        }
+        args.push(...canister.args);
+    }
+    if (extraArgs) {
+        args.push(...extraArgs);
+    }
+    const warned = new Set();
+    for (const arg of args) {
+        const hint = managedFlags[arg];
+        if (hint && !warned.has(arg)) {
+            warned.add(arg);
+            console.warn(chalk.yellow(`Warning: '${arg}' in args for canister ${canisterName} may conflict with mops build — ${hint}`));
+        }
+    }
+    return args;
+}

package/dist/commands/check-stable.js

@@ -4,7 +4,7 @@ import { rename, rm } from "node:fs/promises";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
-import { getGlobalMocArgs, readConfig } from "../mops.js";
+import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
 import { resolveSingleCanister } from "../helpers/resolve-canisters.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
@@ -19,7 +19,7 @@ export async function checkStable(oldFile, canisterName, options = {}) {
     const globalMocArgs = getGlobalMocArgs(config);
     await runStableCheck({
         oldFile,
-        canisterMain: canister.main,
+        canisterMain: resolveConfigPath(canister.main),
         canisterName: name,
         mocPath,
         globalMocArgs,

package/dist/commands/check.js

@@ -1,9 +1,9 @@
-import { relative } from "node:path";
+import path from "node:path";
 import { existsSync } from "node:fs";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
-import { getGlobalMocArgs, readConfig } from "../mops.js";
+import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
 import { autofixMotoko } from "../helpers/autofix-motoko.js";
 import { getMocSemVer } from "../helpers/get-moc-version.js";
 import { resolveCanisterConfigs, resolveCanisterEntrypoints, } from "../helpers/resolve-canisters.js";
@@ -19,7 +19,7 @@ export async function check(files, options = {}) {
     let fileList = Array.isArray(files) ? files : files ? [files] : [];
     const config = readConfig();
     if (fileList.length === 0) {
-        fileList = resolveCanisterEntrypoints(config);
+        fileList = resolveCanisterEntrypoints(config).map(resolveConfigPath);
     }
     if (fileList.length === 0) {
         cliError("No Motoko files specified and no canisters defined in mops.toml.\n" +
@@ -55,7 +55,7 @@ export async function check(files, options = {}) {
             for (const [file, codes] of fixResult.fixedFiles) {
                 const unique = [...new Set(codes)].sort();
                 const n = codes.length;
-                const rel = relative(process.cwd(), file);
+                const rel = path.relative(process.cwd(), file);
                 console.log(chalk.green(`Fixed ${rel} (${n} ${n === 1 ? "fix" : "fixes"}: ${unique.join(", ")})`));
             }
             const fileCount = fixResult.fixedFiles.size;
@@ -96,18 +96,19 @@ export async function check(files, options = {}) {
         if (!canister.main) {
             cliError(`No main file specified for canister '${name}' in mops.toml`);
         }
-        if (!existsSync(stableConfig.path)) {
+        const stablePath = resolveConfigPath(stableConfig.path);
+        if (!existsSync(stablePath)) {
             if (stableConfig.skipIfMissing) {
                 continue;
             }
-            cliError(`Deployed file not found: ${stableConfig.path} (canister '${name}')\n` +
+            cliError(`Deployed file not found: ${stablePath} (canister '${name}')\n` +
                 "Set skipIfMissing = true in [canisters." +
                 name +
                 ".check-stable] to skip this check when the file is missing.");
         }
         await runStableCheck({
-            oldFile: stableConfig.path,
-            canisterMain: canister.main,
+            oldFile: stablePath,
+            canisterMain: resolveConfigPath(canister.main),
             canisterName: name,
             mocPath,
             globalMocArgs,

package/dist/commands/replica.d.ts

@@ -1,8 +1,7 @@
 import { ChildProcessWithoutNullStreams } from "node:child_process";
 import { PassThrough } from "node:stream";
 import { IDL } from "@icp-sdk/core/candid";
-import { PocketIc, PocketIcServer } from "pic-ic";
-import { PocketIc as PocketIcMops, PocketIcServer as PocketIcServerMops } from "pic-js-mops";
+import { type AnyPocketIcServer, type AnyPocketIc } from "../helpers/pocket-ic-client.js";
 type StartOptions = {
     type?: "dfx" | "pocket-ic" | "dfx-pocket-ic";
     dir?: string;
@@ -18,8 +17,8 @@ export declare class Replica {
         actor: any;
         stream: PassThrough;
     }>;
-    pocketIcServer?: PocketIcServer | PocketIcServerMops;
-    pocketIc?: PocketIc | PocketIcMops;
+    pocketIcServer?: AnyPocketIcServer;
+    pocketIc?: AnyPocketIc;
     dfxProcess?: ChildProcessWithoutNullStreams;
     dir: string;
     ttl: number;

package/dist/commands/replica.js

@@ -5,10 +5,8 @@ import fs from "node:fs";
 import { PassThrough } from "node:stream";
 import { spawn as spawnAsync } from "promisify-child-process";
 import { Actor, HttpAgent } from "@icp-sdk/core/agent";
-import { PocketIc, PocketIcServer } from "pic-ic";
-import { PocketIc as PocketIcMops, PocketIcServer as PocketIcServerMops, } from "pic-js-mops";
 import chalk from "chalk";
-import { readConfig } from "../mops.js";
+import { startPocketIc, } from "../helpers/pocket-ic-client.js";
 import { toolchain } from "./toolchain/index.js";
 import { getDfxVersion } from "../helpers/get-dfx-version.js";
 export class Replica {
@@ -74,32 +72,14 @@ export class Replica {
         }
         else {
             let pocketIcBin = await toolchain.bin("pocket-ic");
-            let config = readConfig();
-            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);
-            }
-            // pocket-ic 9.x.x
-            if (config.toolchain?.["pocket-ic"]?.startsWith("9.")) {
-                this.pocketIcServer = await PocketIcServerMops.start({
-                    showRuntimeLogs: false,
-                    showCanisterLogs: false,
-                    binPath: pocketIcBin,
-                    ttl: this.ttl,
-                });
-                this.pocketIc = await PocketIcMops.create(this.pocketIcServer.getUrl());
-            }
-            // pocket-ic 4.0.0
-            else {
-                this.pocketIcServer = await PocketIcServer.start({
-                    showRuntimeLogs: false,
-                    showCanisterLogs: false,
-                    binPath: pocketIcBin,
-                    ttl: this.ttl,
-                });
-                this.pocketIc = await PocketIc.create(this.pocketIcServer.getUrl());
-            }
+            let pic = await startPocketIc({
+                binPath: pocketIcBin,
+                showRuntimeLogs: false,
+                showCanisterLogs: false,
+                ttl: this.ttl,
+            });
+            this.pocketIcServer = pic.server;
+            this.pocketIc = pic.client;
             // process canister logs
             this._attachCanisterLogHandler(this.pocketIcServer.serverProcess);
         }

package/dist/helpers/pocket-ic-client.d.ts

@@ -0,0 +1,9 @@
+import { PocketIc, PocketIcServer } from "pic-ic";
+import { PocketIc as PocketIcModern, PocketIcServer as PocketIcServerModern, type StartServerOptions } from "pic-js-mops";
+export type AnyPocketIcServer = PocketIcServer | PocketIcServerModern;
+export type AnyPocketIc = PocketIc | PocketIcModern;
+export type AnySetupCanister = PocketIc["setupCanister"] & PocketIcModern["setupCanister"];
+export declare function startPocketIc(options: StartServerOptions): Promise<{
+    server: AnyPocketIcServer;
+    client: AnyPocketIc;
+}>;

package/dist/helpers/pocket-ic-client.js

@@ -0,0 +1,18 @@
+import semver from "semver";
+import { PocketIc, PocketIcServer } from "pic-ic";
+import { PocketIc as PocketIcModern, PocketIcServer as PocketIcServerModern, } from "pic-js-mops";
+import { readConfig } from "../mops.js";
+function isLegacy() {
+    let version = readConfig().toolchain?.["pocket-ic"];
+    return !!version && !!semver.valid(version) && semver.lt(version, "9.0.0");
+}
+export async function startPocketIc(options) {
+    if (isLegacy()) {
+        let server = await PocketIcServer.start(options);
+        let client = await PocketIc.create(server.getUrl());
+        return { server, client };
+    }
+    let server = await PocketIcServerModern.start(options);
+    let client = await PocketIcModern.create(server.getUrl());
+    return { server, client };
+}

package/dist/mops.d.ts

@@ -11,6 +11,11 @@ export declare function setNetwork(network: string): void;
 export declare let getIdentity: () => Promise<Identity | undefined>;
 export declare function getClosestConfigFile(dir?: string): string;
 export declare function getRootDir(): string;
+/**
+ * Resolve a path from mops.toml config (relative to project root)
+ * into a path relative to the current working directory.
+ */
+export declare function resolveConfigPath(configPath: string): string;
 export declare function checkConfigFile(exit?: boolean): boolean;
 export declare function progressBar(step: number, total: number): string;
 export declare function parseGithubURL(href: string): {

package/dist/mops.js

@@ -87,6 +87,13 @@ export function getRootDir() {
     }
     return path.dirname(configFile);
 }
+/**
+ * Resolve a path from mops.toml config (relative to project root)
+ * into a path relative to the current working directory.
+ */
+export function resolveConfigPath(configPath) {
+    return path.relative(process.cwd(), path.resolve(getRootDir(), configPath));
+}
 export function checkConfigFile(exit = false) {
     let configFile = getClosestConfigFile();
     if (!configFile) {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",

package/dist/release-cli.js

@@ -8,8 +8,12 @@ import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex } from "@noble/hashes/utils";
 import { findChangelogEntry } from "./helpers/find-changelog-entry.js";
 let __dirname = new URL(".", import.meta.url).pathname;
-// build using Docker
-execSync("./build.sh", { stdio: "inherit", cwd: __dirname });
+if (!process.env.SKIP_BUILD) {
+    execSync("./build.sh", { stdio: "inherit", cwd: __dirname });
+}
+else if (!fs.existsSync(path.resolve(__dirname, "bundle/cli.tgz"))) {
+    throw new Error("SKIP_BUILD is set but bundle/cli.tgz does not exist. Run build.sh first.");
+}
 let commitHash = process.env.COMMIT_HASH || execSync("git rev-parse HEAD").toString().trim();
 let version = JSON.parse(fs.readFileSync(path.resolve(__dirname, "package.json"), "utf8")).version;
 let major = semver.parse(version)?.major;

package/dist/tests/build.test.js

@@ -1,22 +1,84 @@
 import { describe, expect, test } from "@jest/globals";
 import { execa } from "execa";
-import { existsSync } from "node:fs";
+import { existsSync, rmSync } from "node:fs";
 import path from "path";
-import { cliSnapshot } from "./helpers";
+import { cli, cliSnapshot } from "./helpers";
 const distBin = path.resolve(import.meta.dirname, "../dist/bin/mops.js");
+function cleanFixture(cwd, ...extras) {
+    rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+    for (const p of extras) {
+        rmSync(p, { recursive: true, force: true });
+    }
+}
 describe("build", () => {
     test("ok", async () => {
         const cwd = path.join(import.meta.dirname, "build/success");
-        await cliSnapshot(["build", "--verbose"], { cwd }, 0);
-        await cliSnapshot(["build", "foo"], { cwd }, 0);
-        await cliSnapshot(["build", "bar"], { cwd }, 0);
-        await cliSnapshot(["build", "foo", "bar"], { cwd }, 0);
+        try {
+            await cliSnapshot(["build", "--verbose"], { cwd }, 0);
+            await cliSnapshot(["build", "foo"], { cwd }, 0);
+            await cliSnapshot(["build", "bar"], { cwd }, 0);
+            await cliSnapshot(["build", "foo", "bar"], { cwd }, 0);
+        }
+        finally {
+            cleanFixture(cwd);
+        }
     });
     test("error", async () => {
         const cwd = path.join(import.meta.dirname, "build/error");
-        await cliSnapshot(["build", "foo", "--verbose"], { cwd }, 0);
-        expect((await cliSnapshot(["build", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
-        expect((await cliSnapshot(["build", "foo", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
+        try {
+            await cliSnapshot(["build", "foo", "--verbose"], { cwd }, 0);
+            expect((await cliSnapshot(["build", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
+            expect((await cliSnapshot(["build", "foo", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
+        }
+        finally {
+            cleanFixture(cwd);
+        }
+    });
+    // [build].outputDir in mops.toml should control where build output goes
+    test("custom output path via config outputDir", async () => {
+        const cwd = path.join(import.meta.dirname, "build/custom-output");
+        const customOut = path.join(cwd, "custom-out");
+        const customWasm = path.join(customOut, "main.wasm");
+        const customDid = path.join(customOut, "main.did");
+        const defaultDid = path.join(cwd, ".mops/.build/main.did");
+        try {
+            const result = await cli(["build"], { cwd });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(customWasm)).toBe(true);
+            expect(existsSync(customDid)).toBe(true);
+            expect(existsSync(defaultDid)).toBe(false);
+        }
+        finally {
+            cleanFixture(cwd, customOut);
+        }
+    });
+    // Regression: --output CLI option was silently ignored due to
+    // Commander storing it as options.output while build() read options.outputDir
+    test("--output CLI option", async () => {
+        const cwd = path.join(import.meta.dirname, "build/success");
+        const outputDir = path.join(cwd, "cli-output-test");
+        try {
+            const result = await cli(["build", "foo", "--output", outputDir], {
+                cwd,
+            });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(path.join(outputDir, "foo.wasm"))).toBe(true);
+            expect(existsSync(path.join(outputDir, "foo.did"))).toBe(true);
+        }
+        finally {
+            cleanFixture(cwd, outputDir);
+        }
+    });
+    test("warns when args contain managed flags", async () => {
+        const cwd = path.join(import.meta.dirname, "build/success");
+        const artifact = path.join(cwd, "x");
+        const artifactDid = path.join(cwd, "x.did");
+        try {
+            await cliSnapshot(["build", "foo", "--", "-o", "x", "-c", "--idl"], { cwd }, 1);
+        }
+        finally {
+            cleanFixture(cwd, artifact, artifactDid);
+        }
     });
     // Regression: bin/mops.js must route through environments/nodejs/cli.js
     // so that setWasmBindings() is called before any command runs.
@@ -25,12 +87,17 @@ describe("build", () => {
     const hasDistBin = existsSync(distBin);
     (hasDistBin ? test : test.skip)("wasm bindings initialized via dist entry point", async () => {
         const cwd = path.join(import.meta.dirname, "build/success");
-        const result = await execa("node", [distBin, "build", "foo"], {
-            cwd,
-            stdio: "pipe",
-            reject: false,
-        });
-        expect(result.stderr).not.toContain("Wasm bindings have not been set");
-        expect(result.exitCode).toBe(0);
+        try {
+            const result = await execa("node", [distBin, "build", "foo"], {
+                cwd,
+                stdio: "pipe",
+                reject: false,
+            });
+            expect(result.stderr).not.toContain("Wasm bindings have not been set");
+            expect(result.exitCode).toBe(0);
+        }
+        finally {
+            cleanFixture(cwd);
+        }
     });
 });

package/dist/tests/check.test.js

@@ -38,6 +38,13 @@ describe("check", () => {
         const cwd = path.join(import.meta.dirname, "check/canisters");
         await cliSnapshot(["check"], { cwd }, 0);
     });
+    test("canister entrypoint resolved relative to config root when run from subdirectory", async () => {
+        const fixtureRoot = path.join(import.meta.dirname, "check/canisters-subdir");
+        const subdir = path.join(fixtureRoot, "src/backend");
+        const result = await cli(["check"], { cwd: subdir });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/✓/);
+    });
     test("[moc] args applied when using canister fallback", async () => {
         const cwd = path.join(import.meta.dirname, "check/canisters-moc-args");
         const result = await cli(["check"], { cwd });

package/dist/tests/pocket-ic.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/pocket-ic.test.js

@@ -0,0 +1,12 @@
+import { describe, test, expect } from "@jest/globals";
+import path from "path";
+import { cli } from "./helpers";
+describe("pocket-ic", () => {
+    test("runs tests with pocket-ic 12.0.0", async () => {
+        const cwd = path.join(import.meta.dirname, "pocket-ic");
+        const result = await cli(["test", "--reporter", "verbose", "--replica", "pocket-ic"], { cwd });
+        expect(result.stderr).not.toContain("is not supported");
+        expect(result.stderr).not.toContain("only supports pocket-ic 9.x.x and 4.0.0");
+        expect(result.exitCode).toBe(0);
+    });
+});

package/dist/wasm/pkg/nodejs/wasm_bg.wasm.d.ts

@@ -1,8 +1,8 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const is_candid_compatible: (a: number, b: number, c: number, d: number) => number;
 export const add_custom_sections: (a: number, b: number, c: any) => [number, number, number, number];
+export const is_candid_compatible: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/dist/wasm/pkg/web/wasm.d.ts

@@ -9,8 +9,8 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly is_candid_compatible: (a: number, b: number, c: number, d: number) => number;
   readonly add_custom_sections: (a: number, b: number, c: any) => [number, number, number, number];
+  readonly is_candid_compatible: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_exn_store: (a: number) => void;

package/dist/wasm/pkg/web/wasm_bg.wasm.d.ts

@@ -1,8 +1,8 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const is_candid_compatible: (a: number, b: number, c: number, d: number) => number;
 export const add_custom_sections: (a: number, b: number, c: any) => [number, number, number, number];
+export const is_candid_compatible: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/helpers/pocket-ic-client.ts

@@ -0,0 +1,32 @@
+import semver from "semver";
+import { PocketIc, PocketIcServer } from "pic-ic";
+import {
+  PocketIc as PocketIcModern,
+  PocketIcServer as PocketIcServerModern,
+  type StartServerOptions,
+} from "pic-js-mops";
+import { readConfig } from "../mops.js";
+
+export type AnyPocketIcServer = PocketIcServer | PocketIcServerModern;
+export type AnyPocketIc = PocketIc | PocketIcModern;
+export type AnySetupCanister = PocketIc["setupCanister"] &
+  PocketIcModern["setupCanister"];
+
+function isLegacy(): boolean {
+  let version = readConfig().toolchain?.["pocket-ic"];
+  return !!version && !!semver.valid(version) && semver.lt(version, "9.0.0");
+}
+
+export async function startPocketIc(
+  options: StartServerOptions,
+): Promise<{ server: AnyPocketIcServer; client: AnyPocketIc }> {
+  if (isLegacy()) {
+    let server = await PocketIcServer.start(options);
+    let client = await PocketIc.create(server.getUrl());
+    return { server, client };
+  }
+
+  let server = await PocketIcServerModern.start(options);
+  let client = await PocketIcModern.create(server.getUrl());
+  return { server, client };
+}

package/mops.ts

@@ -100,6 +100,14 @@ export function getRootDir() {
   return path.dirname(configFile);
 }
 
+/**
+ * Resolve a path from mops.toml config (relative to project root)
+ * into a path relative to the current working directory.
+ */
+export function resolveConfigPath(configPath: string): string {
+  return path.relative(process.cwd(), path.resolve(getRootDir(), configPath));
+}
+
 export function checkConfigFile(exit = false) {
   let configFile = getClosestConfigFile();
   if (!configFile) {