ic-mops 2.2.1 → 2.3.0

package/CHANGELOG.md

@@ -2,8 +2,18 @@
 
 ## Next
 
+## 2.3.0
+- Add `mops check-stable` command for stable variable compatibility checking
+- `mops check` now falls back to canister entrypoints from `mops.toml` when no files are specified
+- `mops check` automatically runs stable compatibility when `[canisters.<name>.check-stable]` is configured
+- `mops check --fix` now behaves like fix + `mops check` — reports changed files, then type-checks and runs stable compatibility if configured
+- `skipIfMissing` in `[canisters.<name>.check-stable]` silently skips when the file doesn't exist
+- Add docs for `mops lint`, `mops moc-args`, `[canisters]`, `[build]`, and `[lint]` config sections
+- Add docs canister deployment step to release process
+
 ## 2.2.1
 - Fix `mops toolchain` when toolchain version is a local file path with subdirectories.
+- Update Motoko formatter (`prettier-plugin-motoko`).
 
 ## 2.2.0
 - Add `[moc]` config section for global `moc` compiler flags (applied to `check`, `build`, `test`, `bench`, `watch`)

package/RELEASE.md

@@ -130,7 +130,15 @@ dfx deploy --network ic --no-wallet cli --identity mops
 
 This deploys the `cli-releases` canister (serving `cli.mops.one`) to the Internet Computer mainnet.
 
-### 10. Commit and push release artifacts
+### 10. Deploy the docs canister
+
+```bash
+dfx deploy --network ic --no-wallet docs --identity mops
+```
+
+This builds the Docusaurus site (`docs/`) and deploys the `docs` assets canister (serving `docs.mops.one`). Docs are not auto-deployed, so this step ensures any documentation changes from the release are published.
+
+### 11. Commit and push release artifacts
 
 Step 8 generates files in `cli-releases/` that must be committed and pushed:
 

package/cli.ts

@@ -12,6 +12,7 @@ import { build, DEFAULT_BUILD_OUTPUT_DIR } from "./commands/build.js";
 import { bump } from "./commands/bump.js";
 import { check } from "./commands/check.js";
 import { checkCandid } from "./commands/check-candid.js";
+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";
@@ -322,9 +323,9 @@ program
 
 // check
 program
-  .command("check <files...>")
+  .command("check [files...]")
   .description(
-    "Check Motoko entrypoint files for syntax errors and type issues (including transitively imported files)",
+    "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",
   )
   .option("--verbose", "Verbose console output")
   .addOption(
@@ -362,6 +363,28 @@ program
     await checkCandid(newCandid, originalCandid);
   });
 
+// 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",
+  )
+  .option("--verbose", "Verbose console output")
+  .allowUnknownOption(true)
+  .action(async (oldFile, canister, options) => {
+    checkConfigFile(true);
+    const { extraArgs } = parseExtraArgs();
+    await installAll({
+      silent: true,
+      lock: "ignore",
+      installFromLockFile: true,
+    });
+    await checkStable(oldFile, canister, {
+      ...options,
+      extraArgs,
+    });
+  });
+
 // test
 program
   .command("test [filter]")

package/commands/build.ts

@@ -5,9 +5,9 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { cliError } from "../error.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
+import { resolveCanisterConfigs } from "../helpers/resolve-canisters.js";
 import { CustomSection, getWasmBindings } from "../wasm.js";
 import { getGlobalMocArgs, readConfig } from "../mops.js";
-import { CanisterConfig } from "../types.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 
@@ -29,16 +29,8 @@ export async function build(
 
   let outputDir = options.outputDir ?? DEFAULT_BUILD_OUTPUT_DIR;
   let mocPath = await toolchain.bin("moc", { fallback: true });
-  let canisters: Record<string, CanisterConfig> = {};
   let config = readConfig();
-  if (config.canisters) {
-    canisters =
-      Object.fromEntries(
-        Object.entries(config.canisters).map(([name, c]) =>
-          typeof c === "string" ? [name, { main: c }] : [name, c],
-        ),
-      ) ?? {};
-  }
+  let canisters = resolveCanisterConfigs(config);
   if (!Object.keys(canisters).length) {
     cliError(`No Motoko canisters found in mops.toml configuration`);
   }

package/commands/check-stable.ts

@@ -0,0 +1,177 @@
+import { basename, join, relative, resolve } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+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 { resolveSingleCanister } from "../helpers/resolve-canisters.js";
+import { sourcesArgs } from "./sources.js";
+import { toolchain } from "./toolchain/index.js";
+
+const CHECK_STABLE_DIR = ".mops/.check-stable";
+
+export interface CheckStableOptions {
+  verbose: boolean;
+  extraArgs: string[];
+}
+
+export async function checkStable(
+  oldFile: string,
+  canisterName: string | undefined,
+  options: Partial<CheckStableOptions> = {},
+): Promise<void> {
+  const config = readConfig();
+  const { name, canister } = resolveSingleCanister(config, canisterName);
+
+  if (!canister.main) {
+    cliError(`No main file specified for canister '${name}' in mops.toml`);
+  }
+
+  const mocPath = await toolchain.bin("moc", { fallback: true });
+  const globalMocArgs = getGlobalMocArgs(config);
+
+  await runStableCheck({
+    oldFile,
+    canisterMain: canister.main,
+    canisterName: name,
+    mocPath,
+    globalMocArgs,
+    options,
+  });
+}
+
+export interface RunStableCheckParams {
+  oldFile: string;
+  canisterMain: string;
+  canisterName: string;
+  mocPath: string;
+  globalMocArgs: string[];
+  options?: Partial<CheckStableOptions>;
+}
+
+export async function runStableCheck(
+  params: RunStableCheckParams,
+): Promise<void> {
+  const {
+    oldFile,
+    canisterMain,
+    canisterName,
+    mocPath,
+    globalMocArgs,
+    options = {},
+  } = params;
+
+  const checkStableDir = resolve(CHECK_STABLE_DIR);
+  const sources = (await sourcesArgs({ cwd: checkStableDir })).flat();
+  const isOldMostFile = oldFile.endsWith(".most");
+
+  if (!existsSync(oldFile)) {
+    cliError(`File not found: ${oldFile}`);
+  }
+
+  await rm(CHECK_STABLE_DIR, { recursive: true, force: true });
+  mkdirSync(CHECK_STABLE_DIR, { recursive: true });
+  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,
+    );
+
+    if (options.verbose) {
+      console.log(
+        chalk.blue("check-stable"),
+        chalk.gray(`Comparing ${oldMostPath} ↔ ${newMostPath}`),
+      );
+    }
+
+    const args = ["--stable-compatible", oldMostPath, newMostPath];
+    if (options.verbose) {
+      console.log(chalk.gray(mocPath, JSON.stringify(args)));
+    }
+
+    const result = await execa(mocPath, args, {
+      stdio: "pipe",
+      reject: false,
+    });
+
+    if (result.exitCode !== 0) {
+      if (result.stderr) {
+        console.error(result.stderr);
+      }
+      cliError(
+        `✗ Stable compatibility check failed for canister '${canisterName}'`,
+      );
+    }
+
+    console.log(
+      chalk.green(
+        `✓ Stable compatibility check passed for canister '${canisterName}'`,
+      ),
+    );
+  } finally {
+    await rm(CHECK_STABLE_DIR, { recursive: true, force: true });
+  }
+}
+
+async function generateStableTypes(
+  mocPath: string,
+  moFile: string,
+  outputPath: string,
+  sources: string[],
+  globalMocArgs: string[],
+  options: Partial<CheckStableOptions>,
+): Promise<string> {
+  const relFile = relative(resolve(CHECK_STABLE_DIR), resolve(moFile));
+  const args = [
+    "--stable-types",
+    relFile,
+    ...sources,
+    ...globalMocArgs,
+    ...(options.extraArgs ?? []),
+  ];
+
+  if (options.verbose) {
+    console.log(
+      chalk.blue("check-stable"),
+      chalk.gray(`Generating stable types for ${moFile}`),
+    );
+    console.log(chalk.gray(mocPath, JSON.stringify(args)));
+  }
+
+  const result = await execa(mocPath, args, {
+    cwd: CHECK_STABLE_DIR,
+    stdio: "pipe",
+    reject: false,
+  });
+
+  if (result.exitCode !== 0) {
+    if (result.stderr) {
+      console.error(result.stderr);
+    }
+    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 });
+
+  return outputPath;
+}

package/commands/check.ts

@@ -1,10 +1,16 @@
 import { relative } 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 { 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";
 
@@ -25,13 +31,23 @@ export async function check(
   files: string | string[],
   options: Partial<CheckOptions> = {},
 ): Promise<void> {
-  const fileList = Array.isArray(files) ? files : [files];
+  let fileList = Array.isArray(files) ? files : files ? [files] : [];
+
+  const config = readConfig();
 
   if (fileList.length === 0) {
-    cliError("No Motoko files specified for checking");
+    fileList = resolveCanisterEntrypoints(config);
   }
 
-  const config = readConfig();
+  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);
@@ -109,13 +125,44 @@ export async function check(
         );
       }
 
-      if (!options.fix) {
-        console.log(chalk.green(`✓ ${file}`));
-      }
+      console.log(chalk.green(`✓ ${file}`));
     } catch (err: any) {
       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`);
+    }
+
+    if (!existsSync(stableConfig.path)) {
+      if (stableConfig.skipIfMissing) {
+        continue;
+      }
+      cliError(
+        `Deployed file not found: ${stableConfig.path} (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,
+      canisterName: name,
+      mocPath,
+      globalMocArgs,
+      options: { verbose: options.verbose, extraArgs: options.extraArgs },
+    });
+  }
 }

package/dist/cli.js

@@ -11,6 +11,7 @@ import { build, DEFAULT_BUILD_OUTPUT_DIR } from "./commands/build.js";
 import { bump } from "./commands/bump.js";
 import { check } from "./commands/check.js";
 import { checkCandid } from "./commands/check-candid.js";
+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";
@@ -252,8 +253,8 @@ program
 });
 // check
 program
-    .command("check <files...>")
-    .description("Check Motoko entrypoint files for syntax errors and type issues (including transitively imported files)")
+    .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")
     .option("--verbose", "Verbose console output")
     .addOption(new Option("--fix", "Apply autofixes to all files, including transitively imported ones"))
     .allowUnknownOption(true)
@@ -283,6 +284,25 @@ program
     });
     await checkCandid(newCandid, originalCandid);
 });
+// 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")
+    .option("--verbose", "Verbose console output")
+    .allowUnknownOption(true)
+    .action(async (oldFile, canister, options) => {
+    checkConfigFile(true);
+    const { extraArgs } = parseExtraArgs();
+    await installAll({
+        silent: true,
+        lock: "ignore",
+        installFromLockFile: true,
+    });
+    await checkStable(oldFile, canister, {
+        ...options,
+        extraArgs,
+    });
+});
 // test
 program
     .command("test [filter]")

package/dist/commands/build.js

@@ -5,6 +5,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 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 { sourcesArgs } from "./sources.js";
@@ -16,12 +17,8 @@ export async function build(canisterNames, options) {
     }
     let outputDir = options.outputDir ?? DEFAULT_BUILD_OUTPUT_DIR;
     let mocPath = await toolchain.bin("moc", { fallback: true });
-    let canisters = {};
     let config = readConfig();
-    if (config.canisters) {
-        canisters =
-            Object.fromEntries(Object.entries(config.canisters).map(([name, c]) => typeof c === "string" ? [name, { main: c }] : [name, c])) ?? {};
-    }
+    let canisters = resolveCanisterConfigs(config);
     if (!Object.keys(canisters).length) {
         cliError(`No Motoko canisters found in mops.toml configuration`);
     }

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

@@ -0,0 +1,14 @@
+export interface CheckStableOptions {
+    verbose: boolean;
+    extraArgs: string[];
+}
+export declare function checkStable(oldFile: string, canisterName: string | undefined, options?: Partial<CheckStableOptions>): Promise<void>;
+export interface RunStableCheckParams {
+    oldFile: string;
+    canisterMain: string;
+    canisterName: string;
+    mocPath: string;
+    globalMocArgs: string[];
+    options?: Partial<CheckStableOptions>;
+}
+export declare function runStableCheck(params: RunStableCheckParams): Promise<void>;

package/dist/commands/check-stable.js

@@ -0,0 +1,95 @@
+import { basename, join, relative, resolve } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+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 { resolveSingleCanister } 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`);
+    }
+    const mocPath = await toolchain.bin("moc", { fallback: true });
+    const globalMocArgs = getGlobalMocArgs(config);
+    await runStableCheck({
+        oldFile,
+        canisterMain: canister.main,
+        canisterName: name,
+        mocPath,
+        globalMocArgs,
+        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 isOldMostFile = oldFile.endsWith(".most");
+    if (!existsSync(oldFile)) {
+        cliError(`File not found: ${oldFile}`);
+    }
+    await rm(CHECK_STABLE_DIR, { recursive: true, force: true });
+    mkdirSync(CHECK_STABLE_DIR, { recursive: true });
+    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);
+        if (options.verbose) {
+            console.log(chalk.blue("check-stable"), chalk.gray(`Comparing ${oldMostPath} ↔ ${newMostPath}`));
+        }
+        const args = ["--stable-compatible", oldMostPath, newMostPath];
+        if (options.verbose) {
+            console.log(chalk.gray(mocPath, JSON.stringify(args)));
+        }
+        const result = await execa(mocPath, args, {
+            stdio: "pipe",
+            reject: false,
+        });
+        if (result.exitCode !== 0) {
+            if (result.stderr) {
+                console.error(result.stderr);
+            }
+            cliError(`✗ Stable compatibility check failed for canister '${canisterName}'`);
+        }
+        console.log(chalk.green(`✓ Stable compatibility check passed for canister '${canisterName}'`));
+    }
+    finally {
+        await rm(CHECK_STABLE_DIR, { recursive: true, force: true });
+    }
+}
+async function generateStableTypes(mocPath, moFile, outputPath, sources, globalMocArgs, options) {
+    const relFile = relative(resolve(CHECK_STABLE_DIR), resolve(moFile));
+    const args = [
+        "--stable-types",
+        relFile,
+        ...sources,
+        ...globalMocArgs,
+        ...(options.extraArgs ?? []),
+    ];
+    if (options.verbose) {
+        console.log(chalk.blue("check-stable"), chalk.gray(`Generating stable types for ${moFile}`));
+        console.log(chalk.gray(mocPath, JSON.stringify(args)));
+    }
+    const result = await execa(mocPath, args, {
+        cwd: CHECK_STABLE_DIR,
+        stdio: "pipe",
+        reject: false,
+    });
+    if (result.exitCode !== 0) {
+        if (result.stderr) {
+            console.error(result.stderr);
+        }
+        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 });
+    return outputPath;
+}

package/dist/commands/check.js

@@ -1,10 +1,13 @@
 import { relative } 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 { 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";
 const MOC_ALL_LIBS_MIN_VERSION = "1.3.0";
@@ -13,11 +16,18 @@ function supportsAllLibsFlag() {
     return version ? version.compare(MOC_ALL_LIBS_MIN_VERSION) >= 0 : false;
 }
 export async function check(files, options = {}) {
-    const fileList = Array.isArray(files) ? files : [files];
+    let fileList = Array.isArray(files) ? files : files ? [files] : [];
+    const config = readConfig();
     if (fileList.length === 0) {
-        cliError("No Motoko files specified for checking");
+        fileList = resolveCanisterEntrypoints(config);
+    }
+    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 config = readConfig();
     const mocPath = await toolchain.bin("moc", { fallback: true });
     const sources = await sourcesArgs();
     const globalMocArgs = getGlobalMocArgs(config);
@@ -71,12 +81,37 @@ export async function check(files, options = {}) {
             if (result.exitCode !== 0) {
                 cliError(`✗ Check failed for file ${file} (exit code: ${result.exitCode})`);
             }
-            if (!options.fix) {
-                console.log(chalk.green(`✓ ${file}`));
-            }
+            console.log(chalk.green(`✓ ${file}`));
         }
         catch (err) {
             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`);
+        }
+        if (!existsSync(stableConfig.path)) {
+            if (stableConfig.skipIfMissing) {
+                continue;
+            }
+            cliError(`Deployed file not found: ${stableConfig.path} (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,
+            canisterName: name,
+            mocPath,
+            globalMocArgs,
+            options: { verbose: options.verbose, extraArgs: options.extraArgs },
+        });
+    }
 }

package/dist/helpers/resolve-canisters.d.ts

@@ -0,0 +1,7 @@
+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 resolveSingleCanister(config: Config, canisterName?: string): {
+    name: string;
+    canister: CanisterConfig;
+};

package/dist/helpers/resolve-canisters.js

@@ -0,0 +1,31 @@
+import { cliError } from "../error.js";
+export function resolveCanisterConfigs(config) {
+    if (!config.canisters) {
+        return {};
+    }
+    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 resolveSingleCanister(config, canisterName) {
+    const canisters = resolveCanisterConfigs(config);
+    const names = Object.keys(canisters);
+    if (names.length === 0) {
+        cliError("No canisters defined in mops.toml [canisters] section");
+    }
+    if (canisterName) {
+        const canister = canisters[canisterName];
+        if (!canister) {
+            cliError(`Canister '${canisterName}' not found in mops.toml. Available: ${names.join(", ")}`);
+        }
+        return { name: canisterName, canister };
+    }
+    if (names.length > 1) {
+        cliError(`Multiple canisters defined in mops.toml. Please specify one: ${names.join(", ")}`);
+    }
+    return { name: names[0], canister: canisters[names[0]] };
+}