ic-mops 2.5.0 → 2.6.0

package/commands/watch/warning-checker.ts

@@ -5,7 +5,7 @@ import chalk from "chalk";
 
 import { getMocPath } from "../../helpers/get-moc-path.js";
 import { getGlobalMocArgs, getRootDir, readConfig } from "../../mops.js";
-import { sources } from "../sources.js";
+import { sourcesArgs } from "../sources.js";
 import { ErrorChecker } from "./error-checker.js";
 import { parallel } from "../../parallel.js";
 import { globMoFiles } from "./globMoFiles.js";
@@ -69,7 +69,7 @@ export class WarningChecker {
 
     let rootDir = getRootDir();
     let mocPath = getMocPath();
-    let deps = await sources({ cwd: rootDir });
+    let deps = (await sourcesArgs({ cwd: rootDir })).flat();
     let globalMocArgs = getGlobalMocArgs(readConfig());
     let paths = globMoFiles(rootDir);
 
@@ -83,12 +83,7 @@ export class WarningChecker {
 
       let { stderr } = await promisify(execFile)(
         mocPath,
-        [
-          "--check",
-          ...deps.flatMap((x) => x.split(" ")),
-          ...globalMocArgs,
-          file,
-        ],
+        ["--check", ...deps, ...globalMocArgs, file],
         { cwd: rootDir, signal },
       ).catch((error) => {
         if (error.code === "ABORT_ERR") {

package/dist/api/network.js

@@ -1,5 +1,5 @@
 export function getNetwork() {
-    return globalThis.MOPS_NETWORK || "ic";
+    return process.env["MOPS_NETWORK"] || globalThis.MOPS_NETWORK || "ic";
 }
 export function getEndpoint(network) {
     let endpoint;

package/dist/cli.js

@@ -255,7 +255,7 @@ program
 // check
 program
     .command("check [files...]")
-    .description("Check Motoko files for syntax errors and type issues. If no files are specified, checks all canister entrypoints from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured")
+    .description("Check Motoko files for syntax errors and type issues. If no files are specified, checks all canister entrypoints from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured, and runs linting if lintoko is configured in [toolchain] and rule directories are present")
     .option("--verbose", "Verbose console output")
     .addOption(new Option("--fix", "Apply autofixes to all files, including transitively imported ones"))
     .allowUnknownOption(true)

package/dist/commands/add.js

@@ -77,9 +77,12 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
         };
     }
     if (pkgDetails.repo) {
-        await installFromGithub(pkgDetails.name, pkgDetails.repo, {
+        let res = await installFromGithub(pkgDetails.name, pkgDetails.repo, {
             verbose: verbose,
         });
+        if (!res) {
+            process.exit(1);
+        }
     }
     else if (!pkgDetails.path) {
         let res = await installMopsDep(pkgDetails.name, pkgDetails.version, {

package/dist/commands/build.js

@@ -12,7 +12,7 @@ import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 export const DEFAULT_BUILD_OUTPUT_DIR = ".mops/.build";
 export async function build(canisterNames, options) {
-    if (canisterNames?.length == 0) {
+    if (canisterNames?.length === 0) {
         cliError("No canisters specified to build");
     }
     let config = readConfig();
@@ -26,14 +26,9 @@ export async function build(canisterNames, options) {
         cliError(`No Motoko canisters found in mops.toml configuration`);
     }
     if (canisterNames) {
-        canisterNames = canisterNames.filter((name) => name in canisters);
-        if (canisterNames.length === 0) {
-            throw new Error("No valid canister names specified");
-        }
-        for (let name of canisterNames) {
-            if (!(name in canisters)) {
-                cliError(`Motoko canister '${name}' not found in mops.toml configuration`);
-            }
+        let invalidNames = canisterNames.filter((name) => !(name in canisters));
+        if (invalidNames.length) {
+            cliError(`Motoko canister(s) not found in mops.toml configuration: ${invalidNames.join(", ")}`);
         }
     }
     if (!(await exists(outputDir))) {
@@ -131,7 +126,7 @@ export async function build(canisterNames, options) {
             cliError(`Error while compiling canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
         }
     }
-    console.log(chalk.green(`\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length == 1 ? "" : "s"} successfully`));
+    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",

package/dist/commands/check.js

@@ -3,20 +3,22 @@ import { existsSync } from "node:fs";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
-import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
+import { getGlobalMocArgs, getRootDir, 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";
 import { runStableCheck } from "./check-stable.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
+import { collectLintRules, lint } from "./lint.js";
 const MOC_ALL_LIBS_MIN_VERSION = "1.3.0";
 function supportsAllLibsFlag() {
     const version = getMocSemVer();
     return version ? version.compare(MOC_ALL_LIBS_MIN_VERSION) >= 0 : false;
 }
 export async function check(files, options = {}) {
-    let fileList = Array.isArray(files) ? files : files ? [files] : [];
+    const explicitFiles = Array.isArray(files) ? files : files ? [files] : [];
+    let fileList = [...explicitFiles];
     const config = readConfig();
     if (fileList.length === 0) {
         fileList = resolveCanisterEntrypoints(config).map(resolveConfigPath);
@@ -115,4 +117,14 @@ export async function check(files, options = {}) {
             options: { verbose: options.verbose, extraArgs: options.extraArgs },
         });
     }
+    if (config.toolchain?.lintoko) {
+        const rootDir = getRootDir();
+        const lintRules = await collectLintRules(config, rootDir);
+        await lint(undefined, {
+            verbose: options.verbose,
+            fix: options.fix,
+            rules: lintRules,
+            files: explicitFiles.length > 0 ? explicitFiles : undefined,
+        });
+    }
 }

package/dist/commands/docs-coverage.js

@@ -1,7 +1,6 @@
 import { readFileSync } from "node:fs";
 import chalk from "chalk";
 import { globSync } from "glob";
-import { JSDOM } from "jsdom";
 import { docs } from "./docs.js";
 export async function docsCoverage(options = {}) {
     let docsDir = ".mops/.docs";
@@ -14,11 +13,11 @@ export async function docsCoverage(options = {}) {
     await docs({
         source,
         output: docsDir,
-        format: "html",
+        format: "adoc",
         silent: true,
     });
-    let files = globSync(`${docsDir}/**/*.html`, {
-        ignore: [`${docsDir}/**/index.html`],
+    let files = globSync(`${docsDir}/**/*.adoc`, {
+        ignore: [`${docsDir}/**/*.test.adoc`, `${docsDir}/test/**/*`],
     });
     let coverages = [];
     for (let file of files) {
@@ -58,33 +57,34 @@ export async function docsCoverage(options = {}) {
     return totalCoverage;
 }
 function docFileCoverage(file) {
-    let dom = new JSDOM(readFileSync(file, "utf-8"));
-    let module = dom.window.document.querySelector("h1")?.textContent || "";
+    let content = readFileSync(file, "utf-8");
+    // Module name is on the line after the [[module.*]] anchor
+    let module = content.match(/^\[\[module\.[^\]]+\]\]\n= (.+)$/m)?.[1]?.trim() || "";
     let moduleFile = `${module}.mo`;
-    let items = [...dom.window.document.querySelectorAll("h4")].map((h4) => {
-        let id = h4.getAttribute("id")?.replace("type.", "");
-        let type = h4.className
-            .replace("-declaration", "")
-            .replace("function", "func");
-        let definition = h4.textContent;
-        let comment = h4.parentElement?.querySelector("p + p")?.textContent;
+    // Split into per-declaration sections at every [[id]] that is NOT [[module.*]]
+    let sections = content.split(/^(?=\[\[(?!module\.))/m).slice(1);
+    let items = sections.map((section) => {
+        let rawId = section.match(/^\[\[([^\]]+)\]\]/)?.[1] ?? "";
+        let id = rawId.replace(/^type\./, "");
+        // mo-doc anchors types as [[type.X]]; classes/values have no prefix → "func"
+        let type = rawId.startsWith("type.") ? "type" : "func";
+        let definition = section.match(/^== (.+)$/m)?.[1]?.trim() ?? "";
+        // Text after the closing ---- is the doc comment (empty when undocumented).
+        // slice(2).join preserves any ---- that appears inside the comment itself.
+        let parts = section.split(/^----$/m);
+        let comment = parts.slice(2).join("----").trim();
         return {
             file: moduleFile,
             id,
             type,
             definition,
             comment,
-            covered: (comment || "").length >= 5,
+            covered: comment.length >= 5,
         };
     });
-    let coverage = 0;
-    if (!items.length) {
-        coverage = 100;
-    }
-    else {
-        coverage =
-            (items.filter((item) => item.covered).length / items.length) * 100;
-    }
+    let coverage = !items.length
+        ? 100
+        : (items.filter((item) => item.covered).length / items.length) * 100;
     return { file: moduleFile, coverage, items };
 }
 function colorizeCoverage(coverage) {

package/dist/commands/install/install-dep.js

@@ -7,12 +7,11 @@ import { getRootDir } from "../../mops.js";
 // returns false if failed
 export async function installDep(dep, { verbose, silent, threads, ignoreTransitive } = {}, parentPkgPath) {
     if (dep.repo) {
-        await installFromGithub(dep.name, dep.repo, {
+        return installFromGithub(dep.name, dep.repo, {
             silent,
             verbose,
             ignoreTransitive,
         });
-        return true;
     }
     else if (dep.path) {
         let depPath = dep.path;
@@ -34,5 +33,6 @@ export async function installDep(dep, { verbose, silent, threads, ignoreTransiti
             ignoreTransitive,
         });
     }
-    return true;
+    console.warn(`Warning: dependency "${dep.name}" has no version, repo, or path`);
+    return false;
 }

package/dist/commands/lint.d.ts

@@ -1,7 +1,10 @@
+import { Config } from "../types.js";
+export declare function collectLintRules(config: Config, rootDir: string): Promise<string[]>;
 export interface LintOptions {
     verbose: boolean;
     fix: boolean;
     rules?: string[];
+    files?: string[];
     extraArgs: string[];
 }
 export declare function lint(filter: string | undefined, options: Partial<LintOptions>): Promise<void>;

package/dist/commands/lint.js

@@ -3,23 +3,88 @@ import { execa } from "execa";
 import { globSync } from "glob";
 import path from "node:path";
 import { cliError } from "../error.js";
-import { getRootDir, readConfig } from "../mops.js";
+import { formatDir, formatGithubDir, getDependencyType, getRootDir, readConfig, } from "../mops.js";
+import { resolvePackages } from "../resolve-packages.js";
 import { toolchain } from "./toolchain/index.js";
 import { MOTOKO_GLOB_CONFIG } from "../constants.js";
 import { existsSync } from "node:fs";
+async function resolveDepRules(config, rootDir) {
+    const ext = config.lint?.extends;
+    if (!ext) {
+        return [];
+    }
+    const resolvedPackages = await resolvePackages();
+    const rules = [];
+    const matched = new Set();
+    const hasRules = new Set();
+    for (const [name, version] of Object.entries(resolvedPackages)) {
+        if (ext !== true && !ext.includes(name)) {
+            continue;
+        }
+        matched.add(name);
+        const depType = getDependencyType(version);
+        let pkgDir;
+        if (depType === "local") {
+            pkgDir = version;
+        }
+        else if (depType === "github") {
+            pkgDir = formatGithubDir(name, version);
+        }
+        else {
+            pkgDir = formatDir(name, version);
+        }
+        const rulesDir = path.join(pkgDir, "rules");
+        if (existsSync(rulesDir)) {
+            rules.push(path.relative(rootDir, rulesDir));
+            hasRules.add(name);
+        }
+    }
+    if (Array.isArray(ext)) {
+        const unresolved = ext.filter((n) => !matched.has(n));
+        if (unresolved.length > 0) {
+            console.warn(chalk.yellow(`[lint] extends: package(s) not found in dependencies: ${unresolved.join(", ")}`));
+        }
+        const noRulesDir = ext.filter((n) => matched.has(n) && !hasRules.has(n));
+        if (noRulesDir.length > 0) {
+            console.warn(chalk.yellow(`[lint] extends: package(s) have no rules/ directory: ${noRulesDir.join(", ")}`));
+        }
+    }
+    return rules;
+}
+export async function collectLintRules(config, rootDir) {
+    const configRules = config.lint?.rules ?? [];
+    for (const d of configRules) {
+        if (!existsSync(path.join(rootDir, d))) {
+            cliError(`[lint] rules: directory '${d}' not found. Check your mops.toml [lint] config.`);
+        }
+    }
+    const localRules = configRules.length > 0
+        ? configRules
+        : ["lint", "lints"].filter((d) => existsSync(path.join(rootDir, d)));
+    const depRules = await resolveDepRules(config, rootDir);
+    return [...localRules, ...depRules];
+}
 export async function lint(filter, options) {
     let config = readConfig();
     let rootDir = getRootDir();
     let lintokoBinPath = config.toolchain?.lintoko
         ? await toolchain.bin("lintoko")
         : "lintoko";
-    let globStr = filter ? `**/*${filter}*.mo` : "**/*.mo";
-    let filesToLint = globSync(path.join(rootDir, globStr), {
-        ...MOTOKO_GLOB_CONFIG,
-        cwd: rootDir,
-    });
-    if (filesToLint.length === 0) {
-        cliError(`No files found for filter '${filter}'`);
+    let filesToLint;
+    if (options.files && options.files.length > 0) {
+        filesToLint = options.files;
+    }
+    else {
+        let globStr = filter ? `**/*${filter}*.mo` : "**/*.mo";
+        filesToLint = globSync(path.join(rootDir, globStr), {
+            ...MOTOKO_GLOB_CONFIG,
+            cwd: rootDir,
+        });
+        if (filesToLint.length === 0) {
+            cliError(filter
+                ? `No files found for filter '${filter}'`
+                : "No .mo files found in the project");
+        }
     }
     let args = [];
     if (options.verbose) {
@@ -28,9 +93,9 @@ export async function lint(filter, options) {
     if (options.fix) {
         args.push("--fix");
     }
-    const rules = options.rules && options.rules.length > 0
+    const rules = options.rules !== undefined
         ? options.rules
-        : ["lint", "lints"].filter((d) => existsSync(path.join(rootDir, d)));
+        : await collectLintRules(config, rootDir);
     rules.forEach((rule) => args.push("--rules", rule));
     if (config.lint?.args) {
         if (typeof config.lint.args === "string") {

package/dist/commands/publish.js

@@ -210,6 +210,7 @@ export async function publish(options = {}) {
         "README.md",
         "LICENSE",
         "NOTICE",
+        "rules/*.toml",
         "!.mops/**",
         "!test/**",
         "!tests/**",
@@ -261,6 +262,13 @@ export async function publish(options = {}) {
             process.exit(1);
         }
     }
+    // pre-flight file count check (must match MAX_PACKAGE_FILES in PackagePublisher.mo)
+    const FILE_LIMIT = 1000;
+    if (files.length > FILE_LIMIT) {
+        console.log(chalk.red("Error: ") +
+            `Too many files (${files.length}). Maximum is ${FILE_LIMIT}.`);
+        process.exit(1);
+    }
     // parse changelog
     console.log("Parsing CHANGELOG.md...");
     let changelog = parseChangelog(config.package.version);
@@ -316,25 +324,25 @@ export async function publish(options = {}) {
         console.log(chalk.red("Error: ") + publishing.err);
         process.exit(1);
     }
-    let puiblishingId = publishing.ok;
+    let publishingId = publishing.ok;
     // upload test stats
     if (options.test) {
-        await actor.uploadTestStats(puiblishingId, {
+        await actor.uploadTestStats(publishingId, {
             passed: BigInt(reporter.passed),
             passedNames: reporter.passedNamesFlat,
         });
     }
     // upload benchmarks
     if (options.bench) {
-        await actor.uploadBenchmarks(puiblishingId, benchmarks);
+        await actor.uploadBenchmarks(publishingId, benchmarks);
     }
     // upload changelog
     if (changelog) {
-        await actor.uploadNotes(puiblishingId, changelog);
+        await actor.uploadNotes(publishingId, changelog);
     }
     // upload docs coverage
     if (options.docs) {
-        await actor.uploadDocsCoverage(puiblishingId, docsCov);
+        await actor.uploadDocsCoverage(publishingId, docsCov);
     }
     // upload files
     await parallel(8, files, async (file) => {
@@ -347,7 +355,7 @@ export async function publish(options = {}) {
         if (file === docsFile) {
             file = path.basename(file);
         }
-        let res = await actor.startFileUpload(puiblishingId, file, BigInt(chunkCount), firstChunk);
+        let res = await actor.startFileUpload(publishingId, file, BigInt(chunkCount), firstChunk);
         if ("err" in res) {
             console.log(chalk.red("Error: ") + res.err);
             process.exit(1);
@@ -356,7 +364,7 @@ export async function publish(options = {}) {
         for (let i = 1; i < chunkCount; i++) {
             let start = i * chunkSize;
             let chunk = Array.from(content.slice(start, start + chunkSize));
-            let res = await actor.uploadFileChunk(puiblishingId, fileId, BigInt(i), chunk);
+            let res = await actor.uploadFileChunk(publishingId, fileId, BigInt(i), chunk);
             if ("err" in res) {
                 console.log(chalk.red("Error: ") + res.err);
                 process.exit(1);
@@ -370,7 +378,7 @@ export async function publish(options = {}) {
     // finish
     progress();
     logUpdate.done();
-    let res = await actor.finishPublish(puiblishingId);
+    let res = await actor.finishPublish(publishingId);
     if ("err" in res) {
         console.log(chalk.red("Error: ") + res.err);
         process.exit(1);
@@ -402,14 +410,14 @@ function parseChangelog(version) {
 async function fetchGitHubReleaseNotes(repo, version) {
     let repoPath = new URL(repo).pathname;
     let res = await fetch(`https://api.github.com/repos${repoPath}/releases/tags/${version}`);
-    let release = await res.json();
+    let release = (await res.json());
     if (release.message === "Not Found") {
         res = await fetch(`https://api.github.com/repos${repoPath}/releases/tags/v${version}`);
-        release = await res.json();
+        release = (await res.json());
         if (release.message === "Not Found") {
             console.log(chalk.yellow(`No GitHub release found with name ${version} or v${version}`));
             return "";
         }
     }
-    return release.body;
+    return release.body ?? "";
 }

package/dist/commands/remove.js

@@ -42,7 +42,10 @@ export async function remove(name, { dev = false, verbose = false, dryRun = fals
         let config = readConfig(configFile);
         let deps = Object.values(config.dependencies || {})
             .map((dep) => {
-            return [dep, ...getTransitiveDependenciesOf(dep.name, dep.version)];
+            return [
+                dep,
+                ...getTransitiveDependenciesOf(dep.name, dep.version, dep.repo),
+            ];
         })
             .flat();
         return deps;
@@ -65,7 +68,7 @@ export async function remove(name, { dev = false, verbose = false, dryRun = fals
     // transitive deps of this package (including itself)
     let transitiveDepsOfPackage = [
         pkgDetails,
-        ...getTransitiveDependenciesOf(name, version),
+        ...getTransitiveDependenciesOf(name, version, pkgDetails.repo),
     ];
     // remove local cache
     for (let dep of transitiveDepsOfPackage) {

package/dist/commands/self.js

@@ -27,7 +27,7 @@ function detectPackageManager() {
 }
 export async function getLatestVersion() {
     let res = await fetch(url + "/tags/latest");
-    return res.text();
+    return (await res.text()).trim();
 }
 export async function update() {
     let latest = await getLatestVersion();

package/dist/commands/sources.js

@@ -27,8 +27,9 @@ export async function sourcesArgs({ conflicts = "ignore", cwd = process.cwd(), }
         }
         // append baseDir
         let pkgBaseDir;
-        if (fs.existsSync(path.join(pkgDir, "mops.toml"))) {
-            let config = readConfig(path.join(pkgDir, "mops.toml"));
+        let resolvedMopsToml = path.resolve(cwd, pkgDir, "mops.toml");
+        if (fs.existsSync(resolvedMopsToml)) {
+            let config = readConfig(resolvedMopsToml);
             pkgBaseDir = path.join(pkgDir, config.package?.baseDir || "src");
         }
         else {

package/dist/commands/sync.js

@@ -8,6 +8,7 @@ import { remove } from "./remove.js";
 import { checkIntegrity } from "../integrity.js";
 import { getMocPath } from "../helpers/get-moc-path.js";
 import { MOTOKO_IGNORE_PATTERNS } from "../constants.js";
+import { getDepName } from "../helpers/get-dep-name.js";
 export async function sync({ lock } = {}) {
     if (!checkConfigFile()) {
         return;
@@ -58,25 +59,19 @@ async function getUsedPackages() {
 }
 async function getMissingPackages() {
     let config = readConfig();
-    let allDeps = [
+    let allDepNames = new Set([
         ...Object.keys(config.dependencies || {}),
         ...Object.keys(config["dev-dependencies"] || {}),
-    ];
-    let missing = new Set(await getUsedPackages());
-    for (let pkg of allDeps) {
-        missing.delete(pkg);
-    }
-    return [...missing];
+    ].map((key) => getDepName(key)));
+    let used = await getUsedPackages();
+    return used.filter((pkg) => !allDepNames.has(pkg));
 }
 async function getUnusedPackages() {
     let config = readConfig();
-    let allDeps = new Set([
+    let allDeps = [
         ...Object.keys(config.dependencies || {}),
         ...Object.keys(config["dev-dependencies"] || {}),
-    ]);
-    let used = await getUsedPackages();
-    for (let pkg of used) {
-        allDeps.delete(pkg);
-    }
-    return [...allDeps];
+    ];
+    let used = new Set(await getUsedPackages());
+    return allDeps.filter((key) => !used.has(getDepName(key)));
 }

package/dist/commands/test/test.js

@@ -9,7 +9,7 @@ import { globSync } from "glob";
 import chokidar from "chokidar";
 import debounce from "debounce";
 import { SemVer } from "semver";
-import { sources } from "../sources.js";
+import { sourcesArgs } from "../sources.js";
 import { getGlobalMocArgs, getRootDir, readConfig } from "../../mops.js";
 import { parallel } from "../../parallel.js";
 import { MMF1 } from "./mmf1.js";
@@ -151,7 +151,7 @@ export async function testWithReporter(reporterName, filter = "", defaultMode =
     }
     reporter.addFiles(files);
     let config = readConfig();
-    let sourcesArr = await sources();
+    let sourcesArr = (await sourcesArgs()).flat();
     let globalMocArgs = getGlobalMocArgs(config);
     if (!mocPath) {
         mocPath = await toolchain.bin("moc", { fallback: true });
@@ -197,7 +197,7 @@ export async function testWithReporter(reporterName, filter = "", defaultMode =
             let mocArgs = [
                 "--hide-warnings",
                 "--error-detail=2",
-                ...sourcesArr.join(" ").split(" "),
+                ...sourcesArr,
                 ...globalMocArgs,
                 file,
             ].filter((x) => x);

package/dist/commands/update.js

@@ -25,9 +25,14 @@ export async function update(pkg, { lock } = {}) {
     for (let dep of githubDeps) {
         let { org, gitName, branch, commitHash } = parseGithubURL(dep.repo || "");
         let dev = !!config["dev-dependencies"]?.[dep.name];
-        let commit = await getGithubCommit(`${org}/${gitName}`, branch);
-        if (commit.sha !== commitHash) {
-            await add(`https://github.com/${org}/${gitName}#${branch}@${commit.sha}`, { dev }, dep.name);
+        try {
+            let commit = await getGithubCommit(`${org}/${gitName}`, branch);
+            if (commit.sha !== commitHash) {
+                await add(`https://github.com/${org}/${gitName}#${branch}@${commit.sha}`, { dev, lock }, dep.name);
+            }
+        }
+        catch (err) {
+            console.log(chalk.red("Error: ") + `Failed to update ${dep.name}: ${err.message}`);
         }
     }
     // update mops packages
@@ -58,7 +63,7 @@ export async function update(pkg, { lock } = {}) {
                 return (getDepName(d) === dep[0] &&
                     (!pinnedVersion || dep[1].startsWith(pinnedVersion)));
             }) || dep[0];
-            await add(`${dep[0]}@${dep[2]}`, { dev }, asName);
+            await add(`${dep[0]}@${dep[2]}`, { dev, lock }, asName);
         }
     }
     await checkIntegrity(lock);

package/dist/commands/watch/error-checker.js

@@ -4,7 +4,7 @@ import os from "node:os";
 import chalk from "chalk";
 import { getMocPath } from "../../helpers/get-moc-path.js";
 import { getGlobalMocArgs, getRootDir, readConfig } from "../../mops.js";
-import { sources } from "../sources.js";
+import { sourcesArgs } from "../sources.js";
 import { parallel } from "../../parallel.js";
 import { globMoFiles } from "./globMoFiles.js";
 export class ErrorChecker {
@@ -30,19 +30,14 @@ export class ErrorChecker {
         onProgress();
         let rootDir = getRootDir();
         let mocPath = getMocPath();
-        let deps = await sources({ cwd: rootDir });
+        let deps = (await sourcesArgs({ cwd: rootDir })).flat();
         let globalMocArgs = getGlobalMocArgs(readConfig());
         let paths = globMoFiles(rootDir);
         this.totalFiles = paths.length;
         this.processedFiles = 0;
         await parallel(os.cpus().length, paths, async (file) => {
             try {
-                await promisify(execFile)(mocPath, [
-                    "--check",
-                    ...deps.flatMap((x) => x.split(" ")),
-                    ...globalMocArgs,
-                    file,
-                ], { cwd: rootDir });
+                await promisify(execFile)(mocPath, ["--check", ...deps, ...globalMocArgs, file], { cwd: rootDir });
             }
             catch (error) {
                 error.message.split("\n").forEach((line) => {