ic-mops 2.9.0 → 2.10.0

package/dist/cli.js

@@ -263,20 +263,20 @@ 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, and runs linting if lintoko is configured in [toolchain] and rule directories are present")
+    .command("check [args...]")
+    .description("Check Motoko canisters or files for syntax errors and type issues. Arguments can be canister names or file paths. If no arguments are given, checks all canisters from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured, and runs linting if lintoko is configured in [toolchain]")
     .option("--verbose", "Verbose console output")
     .addOption(new Option("--fix", "Apply autofixes to all files, including transitively imported ones"))
     .allowUnknownOption(true)
-    .action(async (files, options) => {
+    .action(async (args, options) => {
     checkConfigFile(true);
-    const { extraArgs, args: fileList } = parseExtraArgs(files);
+    const { extraArgs, args: argList } = parseExtraArgs(args);
     await installAll({
         silent: true,
         lock: "ignore",
         installFromLockFile: true,
     });
-    await check(fileList, {
+    await check(argList, {
         ...options,
         extraArgs,
     });
@@ -296,19 +296,19 @@ program
 });
 // check-stable
 program
-    .command("check-stable <old-file> [canister]")
-    .description("Check stable variable compatibility between an old version (.mo or .most file) and the current canister entrypoint")
+    .command("check-stable [args...]")
+    .description("Check stable variable compatibility. With no arguments, checks all canisters with [check-stable] configured. Arguments can be canister names or an old file path followed by an optional canister name")
     .option("--verbose", "Verbose console output")
     .allowUnknownOption(true)
-    .action(async (oldFile, canister, options) => {
+    .action(async (args, options) => {
     checkConfigFile(true);
-    const { extraArgs } = parseExtraArgs();
+    const { extraArgs, args: argList } = parseExtraArgs(args);
     await installAll({
         silent: true,
         lock: "ignore",
         installFromLockFile: true,
     });
-    await checkStable(oldFile, canister, {
+    await checkStable(argList, {
         ...options,
         extraArgs,
     });

package/dist/commands/build.js

@@ -6,7 +6,7 @@ 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";
+import { filterCanisters, resolveCanisterConfigs, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
 import { getWasmBindings } from "../wasm.js";
 import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
 import { sourcesArgs } from "./sources.js";
@@ -26,18 +26,10 @@ export async function build(canisterNames, options) {
     if (!Object.keys(canisters).length) {
         cliError(`No Motoko canisters found in mops.toml configuration`);
     }
-    if (canisterNames) {
-        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))) {
         await mkdir(outputDir, { recursive: true });
     }
-    const filteredCanisters = canisterNames
-        ? Object.fromEntries(Object.entries(canisters).filter(([name]) => canisterNames.includes(name)))
-        : canisters;
+    const filteredCanisters = filterCanisters(canisters, canisterNames);
     for (let [canisterName, canister] of Object.entries(filteredCanisters)) {
         console.log(chalk.blue("build canister"), chalk.bold(canisterName));
         let motokoPath = canister.main;
@@ -181,9 +173,7 @@ function collectExtraArgs(config, canister, canisterName, extraArgs) {
         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}`);
-        }
+        validateCanisterArgs(canister, canisterName);
         args.push(...canister.args);
     }
     if (extraArgs) {

package/dist/commands/check-stable.d.ts

@@ -1,14 +1,20 @@
+import { CanisterConfig } from "../types.js";
 export interface CheckStableOptions {
     verbose: boolean;
     extraArgs: string[];
 }
-export declare function checkStable(oldFile: string, canisterName: string | undefined, options?: Partial<CheckStableOptions>): Promise<void>;
+export declare function resolveStablePath(canister: CanisterConfig, canisterName: string, options?: {
+    required?: boolean;
+}): string | null;
+export declare function checkStable(args: string[], options?: Partial<CheckStableOptions>): Promise<void>;
 export interface RunStableCheckParams {
     oldFile: string;
     canisterMain: string;
     canisterName: string;
     mocPath: string;
     globalMocArgs: string[];
+    canisterArgs: string[];
+    sources?: string[];
     options?: Partial<CheckStableOptions>;
 }
 export declare function runStableCheck(params: RunStableCheckParams): Promise<void>;

package/dist/commands/check-stable.js

@@ -5,30 +5,93 @@ import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
 import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
-import { resolveSingleCanister } from "../helpers/resolve-canisters.js";
+import { filterCanisters, looksLikeFile, resolveCanisterConfigs, resolveSingleCanister, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 const CHECK_STABLE_DIR = ".mops/.check-stable";
-export async function checkStable(oldFile, canisterName, options = {}) {
-    const config = readConfig();
-    const { name, canister } = resolveSingleCanister(config, canisterName);
-    if (!canister.main) {
-        cliError(`No main file specified for canister '${name}' in mops.toml`);
+export function resolveStablePath(canister, canisterName, options) {
+    const stableConfig = canister["check-stable"];
+    if (!stableConfig) {
+        if (options?.required) {
+            cliError(`Canister '${canisterName}' has no [canisters.${canisterName}.check-stable] configuration in mops.toml`);
+        }
+        return null;
     }
+    const stablePath = resolveConfigPath(stableConfig.path);
+    if (!existsSync(stablePath)) {
+        if (stableConfig.skipIfMissing) {
+            return null;
+        }
+        cliError(`Deployed file not found: ${stablePath} (canister '${canisterName}')\n` +
+            "Set skipIfMissing = true in [canisters." +
+            canisterName +
+            ".check-stable] to skip this check when the file is missing.");
+    }
+    return stablePath;
+}
+export async function checkStable(args, options = {}) {
+    const config = readConfig();
     const mocPath = await toolchain.bin("moc", { fallback: true });
     const globalMocArgs = getGlobalMocArgs(config);
-    await runStableCheck({
-        oldFile,
-        canisterMain: resolveConfigPath(canister.main),
-        canisterName: name,
-        mocPath,
-        globalMocArgs,
-        options,
-    });
+    const firstArg = args[0];
+    if (firstArg && looksLikeFile(firstArg)) {
+        const oldFile = firstArg;
+        const canisterName = args[1];
+        const { name, canister } = resolveSingleCanister(config, canisterName);
+        if (!canister.main) {
+            cliError(`No main file specified for canister '${name}' in mops.toml`);
+        }
+        validateCanisterArgs(canister, name);
+        await runStableCheck({
+            oldFile,
+            canisterMain: resolveConfigPath(canister.main),
+            canisterName: name,
+            mocPath,
+            globalMocArgs,
+            canisterArgs: canister.args ?? [],
+            options,
+        });
+        return;
+    }
+    const canisters = resolveCanisterConfigs(config);
+    const canisterNames = args.length > 0 ? args : undefined;
+    const filteredCanisters = filterCanisters(canisters, canisterNames);
+    const sources = (await sourcesArgs()).flat();
+    let checked = 0;
+    for (const [name, canister] of Object.entries(filteredCanisters)) {
+        if (!canister.main) {
+            cliError(`No main file specified for canister '${name}' in mops.toml`);
+        }
+        validateCanisterArgs(canister, name);
+        const stablePath = resolveStablePath(canister, name, {
+            required: !!canisterNames,
+        });
+        if (!stablePath) {
+            continue;
+        }
+        await runStableCheck({
+            oldFile: stablePath,
+            canisterMain: resolveConfigPath(canister.main),
+            canisterName: name,
+            mocPath,
+            globalMocArgs,
+            canisterArgs: canister.args ?? [],
+            sources,
+            options,
+        });
+        checked++;
+    }
+    if (checked === 0 && !canisterNames) {
+        cliError("No canisters with [check-stable] configuration found in mops.toml.\n" +
+            "Either pass an old file: mops check-stable <old-file> [canister]\n" +
+            "Or configure check-stable for a canister:\n\n" +
+            "  [canisters.backend.check-stable]\n" +
+            '  path = "deployed.mo"');
+    }
 }
 export async function runStableCheck(params) {
-    const { oldFile, canisterMain, canisterName, mocPath, globalMocArgs, options = {}, } = params;
-    const sources = (await sourcesArgs()).flat();
+    const { oldFile, canisterMain, canisterName, mocPath, globalMocArgs, canisterArgs, options = {}, } = params;
+    const sources = params.sources ?? (await sourcesArgs()).flat();
     const isOldMostFile = oldFile.endsWith(".most");
     if (!existsSync(oldFile)) {
         cliError(`File not found: ${oldFile}`);
@@ -38,8 +101,8 @@ export async function runStableCheck(params) {
     try {
         const oldMostPath = isOldMostFile
             ? oldFile
-            : await generateStableTypes(mocPath, oldFile, join(CHECK_STABLE_DIR, "old.most"), sources, globalMocArgs, options);
-        const newMostPath = await generateStableTypes(mocPath, canisterMain, join(CHECK_STABLE_DIR, "new.most"), sources, globalMocArgs, options);
+            : await generateStableTypes(mocPath, oldFile, join(CHECK_STABLE_DIR, "old.most"), sources, globalMocArgs, canisterArgs, options);
+        const newMostPath = await generateStableTypes(mocPath, canisterMain, join(CHECK_STABLE_DIR, "new.most"), sources, globalMocArgs, canisterArgs, options);
         if (options.verbose) {
             console.log(chalk.blue("check-stable"), chalk.gray(`Comparing ${oldMostPath} ↔ ${newMostPath}`));
         }
@@ -63,7 +126,7 @@ export async function runStableCheck(params) {
         await rm(CHECK_STABLE_DIR, { recursive: true, force: true });
     }
 }
-async function generateStableTypes(mocPath, moFile, outputPath, sources, globalMocArgs, options) {
+async function generateStableTypes(mocPath, moFile, outputPath, sources, globalMocArgs, canisterArgs, options) {
     const base = basename(outputPath, ".most");
     const wasmPath = join(CHECK_STABLE_DIR, base + ".wasm");
     const args = [
@@ -73,6 +136,7 @@ async function generateStableTypes(mocPath, moFile, outputPath, sources, globalM
         moFile,
         ...sources,
         ...globalMocArgs,
+        ...canisterArgs,
         ...(options.extraArgs ?? []),
     ];
     if (options.verbose) {

package/dist/commands/check.d.ts

@@ -3,4 +3,4 @@ export interface CheckOptions {
     fix: boolean;
     extraArgs: string[];
 }
-export declare function check(files: string | string[], options?: Partial<CheckOptions>): Promise<void>;
+export declare function check(args: string[], options?: Partial<CheckOptions>): Promise<void>;

package/dist/commands/check.js

@@ -1,13 +1,12 @@
 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, 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 { filterCanisters, looksLikeFile, resolveCanisterConfigs, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
+import { resolveStablePath, runStableCheck } from "./check-stable.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 import { collectLintRules, lint } from "./lint.js";
@@ -16,35 +15,137 @@ function supportsAllLibsFlag() {
     const version = getMocSemVer();
     return version ? version.compare(MOC_ALL_LIBS_MIN_VERSION) >= 0 : false;
 }
-export async function check(files, options = {}) {
-    const explicitFiles = Array.isArray(files) ? files : files ? [files] : [];
-    let fileList = [...explicitFiles];
-    const config = readConfig();
-    if (fileList.length === 0) {
-        fileList = resolveCanisterEntrypoints(config).map(resolveConfigPath);
-    }
-    if (fileList.length === 0) {
-        cliError("No Motoko files specified and no canisters defined in mops.toml.\n" +
-            "Either pass files: mops check <files...>\n" +
-            "Or define canisters in mops.toml:\n\n" +
-            "  [canisters.backend]\n" +
-            '  main = "src/main.mo"');
-    }
-    const mocPath = await toolchain.bin("moc", { fallback: true });
-    const sources = await sourcesArgs();
-    const globalMocArgs = getGlobalMocArgs(config);
-    // --all-libs enables richer diagnostics with edit suggestions from moc (requires moc >= 1.3.0)
+function checkAllLibsSupport(verbose) {
     const allLibs = supportsAllLibsFlag();
     if (!allLibs) {
         console.log(chalk.yellow(`moc < ${MOC_ALL_LIBS_MIN_VERSION}: some diagnostic hints may be missing`));
     }
-    else if (options.verbose) {
+    else if (verbose) {
         console.log(chalk.blue("check"), chalk.gray("Using --all-libs for richer diagnostics"));
     }
+    return allLibs;
+}
+function logAutofixResult(fixResult, verbose) {
+    if (fixResult) {
+        for (const [file, codes] of fixResult.fixedFiles) {
+            const unique = [...new Set(codes)].sort();
+            const n = codes.length;
+            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;
+        console.log(chalk.green(`\n✓ ${fixResult.totalFixCount} ${fixResult.totalFixCount === 1 ? "fix" : "fixes"} applied to ${fileCount} ${fileCount === 1 ? "file" : "files"}`));
+    }
+    else if (verbose) {
+        console.log(chalk.yellow("No fixes were needed"));
+    }
+}
+export async function check(args, options = {}) {
+    const config = readConfig();
+    const canisters = resolveCanisterConfigs(config);
+    const hasCanisters = Object.keys(canisters).length > 0;
+    const fileArgs = args.filter(looksLikeFile);
+    const nonFileArgs = args.filter((a) => !looksLikeFile(a));
+    const isFileMode = fileArgs.length > 0;
+    if (isFileMode && nonFileArgs.length > 0) {
+        cliError(`Cannot mix file paths and canister names: ${args.join(", ")}\n` +
+            "Pass either file paths (e.g. mops check src/main.mo) or canister names (e.g. mops check backend)");
+    }
+    if (isFileMode) {
+        await checkFiles(config, fileArgs, options);
+    }
+    else {
+        if (!hasCanisters) {
+            cliError("No canisters defined in mops.toml.\n" +
+                "Either pass files: mops check <files...>\n" +
+                "Or define canisters in mops.toml:\n\n" +
+                "  [canisters.backend]\n" +
+                '  main = "src/main.mo"');
+        }
+        const canisterNames = args.length > 0 ? args : undefined;
+        const filtered = filterCanisters(canisters, canisterNames);
+        await checkCanisters(config, filtered, options);
+    }
+    if (config.toolchain?.lintoko) {
+        const rootDir = getRootDir();
+        const lintRules = await collectLintRules(config, rootDir);
+        const lintFiles = isFileMode ? fileArgs : undefined;
+        await lint(undefined, {
+            verbose: options.verbose,
+            fix: options.fix,
+            rules: lintRules,
+            files: lintFiles,
+        });
+    }
+}
+async function checkCanisters(config, canisters, options) {
+    const mocPath = await toolchain.bin("moc", { fallback: true });
+    const sources = (await sourcesArgs()).flat();
+    const globalMocArgs = getGlobalMocArgs(config);
+    const allLibs = checkAllLibsSupport(options.verbose);
+    for (const [canisterName, canister] of Object.entries(canisters)) {
+        if (!canister.main) {
+            cliError(`No main file specified for canister '${canisterName}' in mops.toml`);
+        }
+        validateCanisterArgs(canister, canisterName);
+        const motokoPath = resolveConfigPath(canister.main);
+        const mocArgs = [
+            "--check",
+            ...(allLibs ? ["--all-libs"] : []),
+            ...sources,
+            ...globalMocArgs,
+            ...(canister.args ?? []),
+            ...(options.extraArgs ?? []),
+        ];
+        if (options.fix) {
+            if (options.verbose) {
+                console.log(chalk.blue("check"), chalk.gray(`Attempting to fix ${canisterName}`));
+            }
+            const fixResult = await autofixMotoko(mocPath, [motokoPath], mocArgs);
+            logAutofixResult(fixResult, options.verbose);
+        }
+        try {
+            const args = [motokoPath, ...mocArgs];
+            if (options.verbose) {
+                console.log(chalk.blue("check"), chalk.gray(`Checking canister ${canisterName}:`));
+                console.log(chalk.gray(mocPath, JSON.stringify(args)));
+            }
+            const result = await execa(mocPath, args, {
+                stdio: "inherit",
+                reject: false,
+            });
+            if (result.exitCode !== 0) {
+                cliError(`✗ Check failed for canister ${canisterName} (exit code: ${result.exitCode})`);
+            }
+            console.log(chalk.green(`✓ ${canisterName}`));
+        }
+        catch (err) {
+            cliError(`Error while checking canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
+        }
+        const stablePath = resolveStablePath(canister, canisterName);
+        if (stablePath) {
+            await runStableCheck({
+                oldFile: stablePath,
+                canisterMain: motokoPath,
+                canisterName,
+                mocPath,
+                globalMocArgs,
+                canisterArgs: canister.args ?? [],
+                sources,
+                options: { verbose: options.verbose, extraArgs: options.extraArgs },
+            });
+        }
+    }
+}
+async function checkFiles(config, files, options) {
+    const mocPath = await toolchain.bin("moc", { fallback: true });
+    const sources = (await sourcesArgs()).flat();
+    const globalMocArgs = getGlobalMocArgs(config);
+    const allLibs = checkAllLibsSupport(options.verbose);
     const mocArgs = [
         "--check",
         ...(allLibs ? ["--all-libs"] : []),
-        ...sources.flat(),
+        ...sources,
         ...globalMocArgs,
         ...(options.extraArgs ?? []),
     ];
@@ -52,24 +153,10 @@ export async function check(files, options = {}) {
         if (options.verbose) {
             console.log(chalk.blue("check"), chalk.gray("Attempting to fix files"));
         }
-        const fixResult = await autofixMotoko(mocPath, fileList, mocArgs);
-        if (fixResult) {
-            for (const [file, codes] of fixResult.fixedFiles) {
-                const unique = [...new Set(codes)].sort();
-                const n = codes.length;
-                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;
-            console.log(chalk.green(`\n✓ ${fixResult.totalFixCount} ${fixResult.totalFixCount === 1 ? "fix" : "fixes"} applied to ${fileCount} ${fileCount === 1 ? "file" : "files"}`));
-        }
-        else {
-            if (options.verbose) {
-                console.log(chalk.yellow("No fixes were needed"));
-            }
-        }
+        const fixResult = await autofixMotoko(mocPath, files, mocArgs);
+        logAutofixResult(fixResult, options.verbose);
     }
-    for (const file of fileList) {
+    for (const file of files) {
         try {
             const args = [file, ...mocArgs];
             if (options.verbose) {
@@ -89,42 +176,4 @@ export async function check(files, options = {}) {
             cliError(`Error while checking ${file}${err?.message ? `\n${err.message}` : ""}`);
         }
     }
-    const canisters = resolveCanisterConfigs(config);
-    for (const [name, canister] of Object.entries(canisters)) {
-        const stableConfig = canister["check-stable"];
-        if (!stableConfig) {
-            continue;
-        }
-        if (!canister.main) {
-            cliError(`No main file specified for canister '${name}' in mops.toml`);
-        }
-        const stablePath = resolveConfigPath(stableConfig.path);
-        if (!existsSync(stablePath)) {
-            if (stableConfig.skipIfMissing) {
-                continue;
-            }
-            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: stablePath,
-            canisterMain: resolveConfigPath(canister.main),
-            canisterName: name,
-            mocPath,
-            globalMocArgs,
-            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/helpers/resolve-canisters.d.ts

@@ -1,7 +1,9 @@
 import { CanisterConfig, Config } from "../types.js";
 export declare function resolveCanisterConfigs(config: Config): Record<string, CanisterConfig>;
-export declare function resolveCanisterEntrypoints(config: Config): string[];
+export declare function filterCanisters(canisters: Record<string, CanisterConfig>, names?: string[]): Record<string, CanisterConfig>;
 export declare function resolveSingleCanister(config: Config, canisterName?: string): {
     name: string;
     canister: CanisterConfig;
 };
+export declare function looksLikeFile(arg: string): boolean;
+export declare function validateCanisterArgs(canister: CanisterConfig, canisterName: string): void;

package/dist/helpers/resolve-canisters.js

@@ -5,11 +5,15 @@ export function resolveCanisterConfigs(config) {
     }
     return Object.fromEntries(Object.entries(config.canisters).map(([name, c]) => typeof c === "string" ? [name, { main: c }] : [name, c]));
 }
-export function resolveCanisterEntrypoints(config) {
-    const canisters = resolveCanisterConfigs(config);
-    return Object.values(canisters)
-        .map((c) => c.main)
-        .filter((main) => Boolean(main));
+export function filterCanisters(canisters, names) {
+    if (!names) {
+        return canisters;
+    }
+    const invalidNames = names.filter((name) => !(name in canisters));
+    if (invalidNames.length) {
+        cliError(`Canister(s) not found in mops.toml: ${invalidNames.join(", ")}. Available: ${Object.keys(canisters).join(", ")}`);
+    }
+    return Object.fromEntries(Object.entries(canisters).filter(([name]) => names.includes(name)));
 }
 export function resolveSingleCanister(config, canisterName) {
     const canisters = resolveCanisterConfigs(config);
@@ -29,3 +33,14 @@ export function resolveSingleCanister(config, canisterName) {
     }
     return { name: names[0], canister: canisters[names[0]] };
 }
+export function looksLikeFile(arg) {
+    return (arg.endsWith(".mo") ||
+        arg.endsWith(".most") ||
+        arg.includes("/") ||
+        arg.includes("\\"));
+}
+export function validateCanisterArgs(canister, canisterName) {
+    if (canister.args && typeof canister.args === "string") {
+        cliError(`Canister config 'args' should be an array of strings for canister ${canisterName}`);
+    }
+}

package/dist/package.json

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

package/dist/tests/check-stable.test.js

@@ -53,6 +53,24 @@ describe("check-stable", () => {
         expect(existsSync(path.join(cwd, "new.most"))).toBe(false);
         expect(existsSync(path.join(cwd, "new.wasm"))).toBe(false);
     });
+    test("[canisters.X].args are passed to moc (enhanced migration)", async () => {
+        const cwd = path.join(import.meta.dirname, "check-stable/canister-args");
+        const result = await cli(["check-stable", "old.most"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    });
+    test("no args checks all canisters with [check-stable] config", async () => {
+        const cwd = path.join(import.meta.dirname, "check/deployed-compatible");
+        const result = await cli(["check-stable"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    });
+    test("canister name filters to specific canister", async () => {
+        const cwd = path.join(import.meta.dirname, "check/deployed-compatible");
+        const result = await cli(["check-stable", "backend"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    });
     test("errors when old file does not exist", async () => {
         const cwd = path.join(import.meta.dirname, "check-stable/compatible");
         const result = await cli(["check-stable", "nonexistent.mo"], { cwd });

package/dist/tests/check.test.js

@@ -34,30 +34,48 @@ describe("check", () => {
         const cwd = path.join(import.meta.dirname, "check/moc-args");
         await cliSnapshot(["check", "Warning.mo"], { cwd }, 1);
     });
-    test("no args falls back to [canisters] entrypoints", async () => {
+    test("no args checks all canisters", async () => {
         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 () => {
+    test("canister name filters to specific canister", async () => {
+        const cwd = path.join(import.meta.dirname, "check/canisters");
+        const result = await cli(["check", "backend"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/✓ backend/);
+    });
+    test("canister 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 () => {
+    test("[moc] args applied to canister check", async () => {
         const cwd = path.join(import.meta.dirname, "check/canisters-moc-args");
         const result = await cli(["check"], { cwd });
         expect(result.exitCode).toBe(1);
         expect(result.stderr).toMatch(/warning \[M0194\]/);
     });
-    test("canister entrypoint with errors", async () => {
+    test("[canisters.X].args applied to canister check", async () => {
+        const cwd = path.join(import.meta.dirname, "check/canisters-canister-args");
+        const result = await cli(["check"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+    });
+    test("canister with errors", async () => {
         const cwd = path.join(import.meta.dirname, "check/canisters-error");
         const result = await cli(["check"], { cwd });
         expect(result.exitCode).toBe(1);
         expect(result.stderr).toMatch(/error/i);
     });
-    test("--fix with canister fallback", async () => {
+    test("invalid canister name errors", async () => {
+        const cwd = path.join(import.meta.dirname, "check/canisters");
+        const result = await cli(["check", "nonexistent"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/not found in mops\.toml/);
+    });
+    test("--fix with canister", async () => {
         const cwd = path.join(import.meta.dirname, "check/canisters");
         const result = await cli(["check", "--fix"], { cwd });
         expect(result.exitCode).toBe(0);