ic-mops 2.8.0 → 2.9.0

package/commands/toolchain/moc.ts

@@ -8,7 +8,7 @@ import * as toolchainUtils from "./toolchain-utils.js";
 
 let cacheDir = path.join(globalCacheDir, "moc");
 
-export let repo = "dfinity/motoko";
+export let repo = "caffeinelabs/motoko";
 
 export let getLatestReleaseTag = async () => {
   return toolchainUtils.getLatestReleaseTag(repo);
@@ -44,7 +44,7 @@ export let download = async (
     }
   } else {
     // Download the .js artifact
-    const jsUrl = `https://github.com/dfinity/motoko/releases/download/${version}/moc-${version}.js`;
+    const jsUrl = `https://github.com/caffeinelabs/motoko/releases/download/${version}/moc-${version}.js`;
     const jsDestPath = path.join(destDir, "moc.js");
 
     if (verbose && !silent) {
@@ -75,14 +75,14 @@ export let download = async (
         ? "arm64"
         : "aarch64"
       : "x86_64";
-    url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+    url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
   } else if (new SemVer(version).compare(new SemVer("0.9.5")) >= 0) {
     let platfrom = process.platform == "darwin" ? "Darwin" : "Linux";
     let arch = "x86_64";
-    url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+    url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
   } else {
     let platfrom = process.platform == "darwin" ? "macos" : "linux64";
-    url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+    url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
   }
 
   if (verbose && !silent) {

package/dist/cli.js

@@ -15,6 +15,7 @@ import { checkStable } from "./commands/check-stable.js";
 import { docsCoverage } from "./commands/docs-coverage.js";
 import { docs } from "./commands/docs.js";
 import { format } from "./commands/format.js";
+import { info } from "./commands/info.js";
 import { init } from "./commands/init.js";
 import { lint } from "./commands/lint.js";
 import { installAll } from "./commands/install/install-all.js";
@@ -213,6 +214,14 @@ program
     .action(async (text) => {
     await search(text);
 });
+// info
+program
+    .command("info <pkg>")
+    .description("Show detailed information about a package from the registry")
+    .option("--versions", "List all published versions, one per line")
+    .action(async (pkg, options) => {
+    await info(pkg, options);
+});
 // cache
 program
     .command("cache")

package/dist/commands/build.js

@@ -3,6 +3,7 @@ import { execa } from "execa";
 import { exists } from "fs-extra";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { lock, unlockSync } from "proper-lockfile";
 import { cliError } from "../error.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
 import { resolveCanisterConfigs } from "../helpers/resolve-canisters.js";
@@ -46,88 +47,120 @@ export async function build(canisterNames, options) {
         motokoPath = resolveConfigPath(motokoPath);
         const wasmPath = join(outputDir, `${canisterName}.wasm`);
         const mostPath = join(outputDir, `${canisterName}.most`);
-        let args = [
-            "-c",
-            "--idl",
-            "--stable-types",
-            "-o",
-            wasmPath,
-            motokoPath,
-            ...(await sourcesArgs()).flat(),
-            ...getGlobalMocArgs(config),
-        ];
-        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) {
-            args.push("--public-metadata", "candid:service");
-            args.push("--public-metadata", "candid:args");
+        // per-canister lock to prevent parallel builds of the same canister from clobbering output files
+        const lockTarget = join(outputDir, `.${canisterName}.buildlock`);
+        await writeFile(lockTarget, "", { flag: "a" });
+        let release;
+        try {
+            release = await lock(lockTarget, {
+                stale: 300_000,
+                retries: { retries: 60, minTimeout: 500, maxTimeout: 5_000 },
+            });
         }
+        catch {
+            cliError(`Failed to acquire build lock for canister ${canisterName} — another build may be stuck`);
+        }
+        // proper-lockfile registers its own signal-exit handler, but it doesn't reliably
+        // fire on process.exit(). This manual handler covers that gap. Double-unlock is
+        // harmless (the second call throws and is caught).
+        const exitCleanup = () => {
+            try {
+                unlockSync(lockTarget);
+            }
+            catch { }
+        };
+        process.on("exit", exitCleanup);
         try {
-            if (options.verbose) {
-                console.log(chalk.gray(mocPath, JSON.stringify(args)));
+            let args = [
+                "-c",
+                "--idl",
+                "--stable-types",
+                "-o",
+                wasmPath,
+                motokoPath,
+                ...(await sourcesArgs()).flat(),
+                ...getGlobalMocArgs(config),
+            ];
+            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) {
+                args.push("--public-metadata", "candid:service");
+                args.push("--public-metadata", "candid:args");
             }
-            const result = await execa(mocPath, args, {
-                stdio: options.verbose ? "inherit" : "pipe",
-                reject: false,
-            });
-            if (result.exitCode !== 0) {
-                if (!options.verbose) {
-                    if (result.stderr) {
-                        console.error(chalk.red(result.stderr));
-                    }
-                    if (result.stdout?.trim()) {
-                        console.error(chalk.yellow("Build output:"));
-                        console.error(result.stdout);
+            try {
+                if (options.verbose) {
+                    console.log(chalk.gray(mocPath, JSON.stringify(args)));
+                }
+                const result = await execa(mocPath, args, {
+                    stdio: options.verbose ? "inherit" : "pipe",
+                    reject: false,
+                });
+                if (result.exitCode !== 0) {
+                    if (!options.verbose) {
+                        if (result.stderr) {
+                            console.error(chalk.red(result.stderr));
+                        }
+                        if (result.stdout?.trim()) {
+                            console.error(chalk.yellow("Build output:"));
+                            console.error(result.stdout);
+                        }
                     }
+                    cliError(`Build failed for canister ${canisterName} (exit code: ${result.exitCode})`);
                 }
-                cliError(`Build failed for canister ${canisterName} (exit code: ${result.exitCode})`);
-            }
-            if (options.verbose && result.stdout && result.stdout.trim()) {
-                console.log(result.stdout);
-            }
-            options.verbose &&
-                console.log(chalk.gray(`Stable types written to ${mostPath}`));
-            const generatedDidPath = join(outputDir, `${canisterName}.did`);
-            const resolvedCandidPath = canister.candid
-                ? resolveConfigPath(canister.candid)
-                : null;
-            if (resolvedCandidPath) {
-                try {
-                    const compatible = await isCandidCompatible(generatedDidPath, resolvedCandidPath);
-                    if (!compatible) {
-                        cliError(`Candid compatibility check failed for canister ${canisterName}`);
+                if (options.verbose && result.stdout && result.stdout.trim()) {
+                    console.log(result.stdout);
+                }
+                options.verbose &&
+                    console.log(chalk.gray(`Stable types written to ${mostPath}`));
+                const generatedDidPath = join(outputDir, `${canisterName}.did`);
+                const resolvedCandidPath = canister.candid
+                    ? resolveConfigPath(canister.candid)
+                    : null;
+                if (resolvedCandidPath) {
+                    try {
+                        const compatible = await isCandidCompatible(generatedDidPath, resolvedCandidPath);
+                        if (!compatible) {
+                            cliError(`Candid compatibility check failed for canister ${canisterName}`);
+                        }
+                        if (options.verbose) {
+                            console.log(chalk.gray(`Candid compatibility check passed for canister ${canisterName}`));
+                        }
                     }
-                    if (options.verbose) {
-                        console.log(chalk.gray(`Candid compatibility check passed for canister ${canisterName}`));
+                    catch (err) {
+                        cliError(`Error during Candid compatibility check for canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
                     }
                 }
-                catch (err) {
-                    cliError(`Error during Candid compatibility check for canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
+                options.verbose &&
+                    console.log(chalk.gray(`Adding metadata to ${wasmPath}`));
+                const candidPath = resolvedCandidPath ?? generatedDidPath;
+                const candidText = await readFile(candidPath, "utf-8");
+                const customSections = [
+                    { name: `${candidVisibility} candid:service`, data: candidText },
+                ];
+                if (canister.initArg) {
+                    customSections.push({
+                        name: `${candidVisibility} candid:args`,
+                        data: canister.initArg,
+                    });
                 }
+                const wasmBytes = await readFile(wasmPath);
+                const newWasm = getWasmBindings().add_custom_sections(wasmBytes, customSections);
+                await writeFile(wasmPath, newWasm);
             }
-            options.verbose &&
-                console.log(chalk.gray(`Adding metadata to ${wasmPath}`));
-            const candidPath = resolvedCandidPath ?? generatedDidPath;
-            const candidText = await readFile(candidPath, "utf-8");
-            const customSections = [
-                { name: `${candidVisibility} candid:service`, data: candidText },
-            ];
-            if (canister.initArg) {
-                customSections.push({
-                    name: `${candidVisibility} candid:args`,
-                    data: canister.initArg,
-                });
+            catch (err) {
+                if (err.message?.includes("Build failed for canister")) {
+                    throw err;
+                }
+                cliError(`Error while compiling canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
             }
-            const wasmBytes = await readFile(wasmPath);
-            const newWasm = getWasmBindings().add_custom_sections(wasmBytes, customSections);
-            await writeFile(wasmPath, newWasm);
         }
-        catch (err) {
-            if (err.message?.includes("Build failed for canister")) {
-                throw err;
+        finally {
+            process.removeListener("exit", exitCleanup);
+            try {
+                await release?.();
             }
-            cliError(`Error while compiling canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
+            catch { }
         }
     }
     console.log(chalk.green(`\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length === 1 ? "" : "s"} successfully`));

package/dist/commands/check-stable.js

@@ -1,6 +1,6 @@
-import { basename, join, relative, resolve } from "node:path";
+import { basename, join } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
-import { rename, rm } from "node:fs/promises";
+import { rm } from "node:fs/promises";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
@@ -28,8 +28,7 @@ export async function checkStable(oldFile, canisterName, options = {}) {
 }
 export async function runStableCheck(params) {
     const { oldFile, canisterMain, canisterName, mocPath, globalMocArgs, options = {}, } = params;
-    const checkStableDir = resolve(CHECK_STABLE_DIR);
-    const sources = (await sourcesArgs({ cwd: checkStableDir })).flat();
+    const sources = (await sourcesArgs()).flat();
     const isOldMostFile = oldFile.endsWith(".most");
     if (!existsSync(oldFile)) {
         cliError(`File not found: ${oldFile}`);
@@ -65,10 +64,13 @@ export async function runStableCheck(params) {
     }
 }
 async function generateStableTypes(mocPath, moFile, outputPath, sources, globalMocArgs, options) {
-    const relFile = relative(resolve(CHECK_STABLE_DIR), resolve(moFile));
+    const base = basename(outputPath, ".most");
+    const wasmPath = join(CHECK_STABLE_DIR, base + ".wasm");
     const args = [
         "--stable-types",
-        relFile,
+        "-o",
+        wasmPath,
+        moFile,
         ...sources,
         ...globalMocArgs,
         ...(options.extraArgs ?? []),
@@ -78,7 +80,6 @@ async function generateStableTypes(mocPath, moFile, outputPath, sources, globalM
         console.log(chalk.gray(mocPath, JSON.stringify(args)));
     }
     const result = await execa(mocPath, args, {
-        cwd: CHECK_STABLE_DIR,
         stdio: "pipe",
         reject: false,
     });
@@ -88,8 +89,6 @@ async function generateStableTypes(mocPath, moFile, outputPath, sources, globalM
         }
         cliError(`Failed to generate stable types for ${moFile} (exit code: ${result.exitCode})`);
     }
-    const base = basename(moFile, ".mo");
-    await rename(join(CHECK_STABLE_DIR, base + ".most"), outputPath);
-    await rm(join(CHECK_STABLE_DIR, base + ".wasm"), { force: true });
+    await rm(wasmPath, { force: true });
     return outputPath;
 }

package/dist/commands/info.d.ts

@@ -0,0 +1,4 @@
+export interface InfoOptions {
+    versions?: boolean;
+}
+export declare function info(pkgArg: string, options?: InfoOptions): Promise<void>;

package/dist/commands/info.js

@@ -0,0 +1,75 @@
+import process from "node:process";
+import chalk from "chalk";
+import { mainActor } from "../api/actors.js";
+import { resolveVersion } from "../api/resolveVersion.js";
+function label(text) {
+    return chalk.bold(text.padEnd(16));
+}
+export async function info(pkgArg, options = {}) {
+    let [name, versionArg] = pkgArg.split("@");
+    let actor = await mainActor();
+    let version;
+    try {
+        version = await resolveVersion(name, versionArg ?? "");
+    }
+    catch (err) {
+        let message = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red("Error: ") + message);
+        process.exit(1);
+    }
+    let res = await actor.getPackageDetails(name, version);
+    if ("err" in res) {
+        console.error(chalk.red("Error: ") + res.err);
+        process.exit(1);
+    }
+    let d = res.ok;
+    let c = d.config;
+    // d.versions is in ascending order (oldest first)
+    if (options.versions) {
+        for (let ver of d.versions) {
+            console.log(ver);
+        }
+        return;
+    }
+    console.log("");
+    console.log(`${chalk.green.bold(c.name)}${chalk.gray("@")}${chalk.yellow(c.version)}`);
+    if (c.description) {
+        console.log(chalk.dim(c.description));
+    }
+    if (c.version !== d.highestVersion) {
+        console.log(chalk.yellow(`latest: ${d.highestVersion}`));
+    }
+    console.log("");
+    if (c.license) {
+        console.log(`${label("license")}${c.license}`);
+    }
+    if (c.repository) {
+        console.log(`${label("repository")}${chalk.cyan(c.repository)}`);
+    }
+    if (c.homepage) {
+        console.log(`${label("homepage")}${chalk.cyan(c.homepage)}`);
+    }
+    if (c.documentation) {
+        console.log(`${label("documentation")}${chalk.cyan(c.documentation)}`);
+    }
+    if (c.dependencies.length > 0) {
+        console.log("");
+        console.log(`${label("dependencies")}${c.dependencies.map((dep) => `${dep.name}${chalk.gray("@")}${dep.version || dep.repo}`).join(", ")}`);
+    }
+    if (c.devDependencies.length > 0) {
+        console.log(`${label("dev-deps")}${c.devDependencies.map((dep) => `${dep.name}${chalk.gray("@")}${dep.version || dep.repo}`).join(", ")}`);
+    }
+    if (c.keywords.length > 0) {
+        console.log("");
+        console.log(`${label("keywords")}${c.keywords.map((k) => chalk.yellow(k)).join(", ")}`);
+    }
+    if (d.versions.length > 0) {
+        let versionsDisplay = d.versions.slice(-10).reverse().join(", ");
+        let extra = d.versions.length > 10
+            ? ` ${chalk.gray(`(+${d.versions.length - 10} more)`)}`
+            : "";
+        console.log("");
+        console.log(`${label("versions")}${versionsDisplay}${extra}`);
+    }
+    console.log("");
+}

package/dist/commands/lint.js

@@ -64,6 +64,43 @@ export async function collectLintRules(config, rootDir) {
     const depRules = await resolveDepRules(config, rootDir);
     return [...localRules, ...depRules];
 }
+function buildCommonArgs(options, config) {
+    const args = [];
+    if (options.verbose) {
+        args.push("--verbose");
+    }
+    if (options.fix) {
+        args.push("--fix");
+    }
+    if (config.lint?.args) {
+        if (typeof config.lint.args === "string") {
+            cliError(`[lint] config 'args' should be an array of strings in mops.toml config file`);
+        }
+        args.push(...config.lint.args);
+    }
+    if (options.extraArgs && options.extraArgs.length > 0) {
+        args.push(...options.extraArgs);
+    }
+    return args;
+}
+async function runLintoko(lintokoBinPath, rootDir, args, options, label) {
+    try {
+        if (options.verbose) {
+            console.log(chalk.blue("lint"), chalk.gray(`Running lintoko (${label}):`));
+            console.log(chalk.gray(lintokoBinPath));
+            console.log(chalk.gray(JSON.stringify(args)));
+        }
+        const result = await execa(lintokoBinPath, args, {
+            cwd: rootDir,
+            stdio: "inherit",
+            reject: false,
+        });
+        return result.exitCode === 0;
+    }
+    catch (err) {
+        cliError(`Error while running lintoko${err?.message ? `\n${err.message}` : ""}`);
+    }
+}
 export async function lint(filter, options) {
     let config = readConfig();
     let rootDir = getRootDir();
@@ -86,49 +123,59 @@ export async function lint(filter, options) {
                 : "No .mo files found in the project");
         }
     }
-    let args = [];
-    if (options.verbose) {
-        args.push("--verbose");
-    }
-    if (options.fix) {
-        args.push("--fix");
-    }
+    const commonArgs = buildCommonArgs(options, config);
+    // --- base run ---
+    const baseArgs = [...commonArgs];
     const rules = options.rules !== undefined
         ? options.rules
         : await collectLintRules(config, rootDir);
-    rules.forEach((rule) => args.push("--rules", rule));
-    if (config.lint?.args) {
-        if (typeof config.lint.args === "string") {
-            cliError(`[lint] config 'args' should be an array of strings in mops.toml config file`);
+    rules.forEach((rule) => baseArgs.push("--rules", rule));
+    baseArgs.push(...filesToLint);
+    let failed = !(await runLintoko(lintokoBinPath, rootDir, baseArgs, options, "base"));
+    // --- extra runs ---
+    const extraEntries = config.lint?.extra;
+    if (extraEntries) {
+        const isFiltered = filter || (options.files && options.files.length > 0);
+        const baseFileSet = isFiltered
+            ? new Set(filesToLint.map((f) => path.resolve(rootDir, f)))
+            : undefined;
+        for (const [globPattern, ruleDirs] of Object.entries(extraEntries)) {
+            if (!Array.isArray(ruleDirs) || ruleDirs.length === 0) {
+                console.warn(chalk.yellow(`[lint.extra] skipping '${globPattern}': value must be a non-empty array of rule directories`));
+                continue;
+            }
+            for (const dir of ruleDirs) {
+                if (!existsSync(path.join(rootDir, dir))) {
+                    cliError(`[lint.extra] rule directory '${dir}' not found (referenced by glob '${globPattern}')`);
+                }
+            }
+            let matchedFiles = globSync(path.join(rootDir, globPattern), {
+                ...MOTOKO_GLOB_CONFIG,
+                cwd: rootDir,
+            });
+            if (baseFileSet) {
+                matchedFiles = matchedFiles.filter((f) => baseFileSet.has(path.resolve(rootDir, f)));
+            }
+            if (matchedFiles.length === 0) {
+                console.warn(chalk.yellow(`[lint.extra] no files matched glob '${globPattern}', skipping`));
+                continue;
+            }
+            const extraArgs = [...commonArgs];
+            for (const dir of ruleDirs) {
+                extraArgs.push("--rules", dir);
+            }
+            extraArgs.push(...matchedFiles);
+            const passed = await runLintoko(lintokoBinPath, rootDir, extraArgs, options, `extra: ${globPattern}`);
+            failed ||= !passed;
         }
-        args.push(...config.lint.args);
     }
-    if (options.extraArgs && options.extraArgs.length > 0) {
-        args.push(...options.extraArgs);
+    if (failed) {
+        cliError("Lint failed");
     }
-    args.push(...filesToLint);
-    try {
-        if (options.verbose) {
-            console.log(chalk.blue("lint"), chalk.gray("Running lintoko:"));
-            console.log(chalk.gray(lintokoBinPath));
-            console.log(chalk.gray(JSON.stringify(args)));
-        }
-        const result = await execa(lintokoBinPath, args, {
-            cwd: rootDir,
-            stdio: "inherit",
-            reject: false,
-        });
-        if (result.exitCode !== 0) {
-            cliError(`Lint failed with exit code ${result.exitCode}`);
-        }
-        if (options.fix) {
-            console.log(chalk.green("✓ Lint fixes applied"));
-        }
-        else {
-            console.log(chalk.green("✓ Lint succeeded"));
-        }
+    else if (options.fix) {
+        console.log(chalk.green("✓ Lint fixes applied"));
     }
-    catch (err) {
-        cliError(`Error while running lintoko${err?.message ? `\n${err.message}` : ""}`);
+    else {
+        console.log(chalk.green("✓ Lint succeeded"));
     }
 }

package/dist/commands/toolchain/moc.js

@@ -5,7 +5,7 @@ import { SemVer } from "semver";
 import { globalCacheDir } from "../../mops.js";
 import * as toolchainUtils from "./toolchain-utils.js";
 let cacheDir = path.join(globalCacheDir, "moc");
-export let repo = "dfinity/motoko";
+export let repo = "caffeinelabs/motoko";
 export let getLatestReleaseTag = async () => {
     return toolchainUtils.getLatestReleaseTag(repo);
 };
@@ -33,7 +33,7 @@ export let download = async (version, { silent = false, verbose = false } = {})
     }
     else {
         // Download the .js artifact
-        const jsUrl = `https://github.com/dfinity/motoko/releases/download/${version}/moc-${version}.js`;
+        const jsUrl = `https://github.com/caffeinelabs/motoko/releases/download/${version}/moc-${version}.js`;
         const jsDestPath = path.join(destDir, "moc.js");
         if (verbose && !silent) {
             console.log(`Downloading ${jsUrl}`);
@@ -61,16 +61,16 @@ export let download = async (version, { silent = false, verbose = false } = {})
                 ? "arm64"
                 : "aarch64"
             : "x86_64";
-        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+        url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
     }
     else if (new SemVer(version).compare(new SemVer("0.9.5")) >= 0) {
         let platfrom = process.platform == "darwin" ? "Darwin" : "Linux";
         let arch = "x86_64";
-        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+        url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
     }
     else {
         let platfrom = process.platform == "darwin" ? "macos" : "linux64";
-        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+        url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
     }
     if (verbose && !silent) {
         console.log(`Downloading ${url}`);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",
@@ -65,6 +65,7 @@
     "prettier-plugin-motoko": "0.13.0",
     "promisify-child-process": "4.1.2",
     "prompts": "2.4.2",
+    "proper-lockfile": "4.1.2",
     "semver": "7.7.1",
     "stream-to-promise": "3.0.0",
     "string-width": "7.2.0",
@@ -81,6 +82,7 @@
     "@types/ncp": "2.0.8",
     "@types/node": "24.0.3",
     "@types/prompts": "2.4.9",
+    "@types/proper-lockfile": "4.1.4",
     "@types/semver": "7.5.8",
     "@types/stream-to-promise": "2.2.4",
     "@types/tar": "6.1.13",

package/dist/templates/mops-publish.yml

@@ -10,7 +10,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - uses: dfinity/setup-mops@v1
+      - uses: caffeinelabs/setup-mops@v1
         with:
           # Make sure you set the MOPS_IDENTITY_PEM secret in your repository settings https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions#creating-secrets-for-a-repository
           identity-pem: ${{ secrets.MOPS_IDENTITY_PEM }}

package/dist/templates/mops-test.yml

@@ -13,7 +13,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - uses: dfinity/setup-mops@v1
+      - uses: caffeinelabs/setup-mops@v1
         with:
           mops-version: 1
 

package/dist/tests/build.test.js

@@ -85,6 +85,23 @@ describe("build", () => {
             cleanFixture(cwd, artifact, artifactDid);
         }
     });
+    test("parallel builds of the same canister both succeed", async () => {
+        const cwd = path.join(import.meta.dirname, "build/success");
+        try {
+            const [a, b] = await Promise.all([
+                cli(["build", "foo"], { cwd }),
+                cli(["build", "foo"], { cwd }),
+            ]);
+            expect(a.exitCode).toBe(0);
+            expect(b.exitCode).toBe(0);
+            expect(existsSync(path.join(cwd, ".mops/.build/foo.wasm"))).toBe(true);
+            expect(existsSync(path.join(cwd, ".mops/.build/foo.did"))).toBe(true);
+            expect(existsSync(path.join(cwd, ".mops/.build/foo.most"))).toBe(true);
+        }
+        finally {
+            cleanFixture(cwd);
+        }
+    });
     // Regression: bin/mops.js must route through environments/nodejs/cli.js
     // so that setWasmBindings() is called before any command runs.
     // The dev entry point (npm run mops) uses tsx and always worked;