ic-mops 2.14.0 → 2.15.0

package/helpers/moc-args.ts

@@ -0,0 +1,123 @@
+import chalk from "chalk";
+import { CanisterConfig, Config } from "../types.js";
+import { cliError } from "../error.js";
+import { getGlobalMocArgs, resolveConfigPath } from "../mops.js";
+import { sourcesArgs } from "../commands/sources.js";
+import { prepareMigrationArgs } from "./migrations.js";
+import { validateCanisterArgs } from "./resolve-canisters.js";
+
+/** Single source of truth for "how moc is invoked for canister X" — keeps
+ * `mops build` and `mops generate candid` in lockstep so the auto-generated
+ * `.did` they each produce stays subtype-compatible with the curated one
+ * embedded by `mops build`. */
+export interface PrepareMocArgsOptions {
+  /** Selects the migration trim limit (`build-limit` vs `check-limit`). */
+  mode: "check" | "build";
+  /** Per-flag hints used when warning about conflicting `args` entries. */
+  managedFlags: Record<string, string>;
+  /** Command label shown in the warning, e.g. "mops build". */
+  commandName: string;
+  verbose?: boolean;
+  extraArgs?: string[];
+}
+
+export interface PreparedMocArgs {
+  motokoPath: string;
+  /** sources + [moc].args + migration + [build].args + [canisters.x].args + CLI extras. */
+  args: string[];
+  /** Cleans up the migration staging dir; call from a `finally`. */
+  cleanup: () => Promise<void>;
+}
+
+export const BUILD_MANAGED_FLAGS: Record<string, string> = {
+  "-o": "use [build].outputDir in mops.toml or --output flag instead",
+  "-c": "this flag is always set by mops build",
+  "--idl": "this flag is always set by mops build",
+  "--stable-types": "this flag is always set by mops build",
+  "--public-metadata": "this flag is managed by mops build",
+};
+
+export const GENERATE_CANDID_MANAGED_FLAGS: Record<string, string> = {
+  "-o": "use the --output flag on `mops generate candid` instead",
+  "-c": "this flag is incompatible with mops generate candid (would also emit .wasm)",
+  "--idl": "this flag is always set by mops generate candid",
+  "--stable-types":
+    "this flag is incompatible with mops generate candid (would also emit .most)",
+};
+
+export async function prepareMocArgs(
+  config: Config,
+  canister: CanisterConfig,
+  canisterName: string,
+  options: PrepareMocArgsOptions,
+): Promise<PreparedMocArgs> {
+  if (!canister.main) {
+    cliError(`No main file is specified for canister ${canisterName}`);
+  }
+  const motokoPath = resolveConfigPath(canister.main);
+
+  const migration = await prepareMigrationArgs(
+    canister.migrations,
+    canisterName,
+    options.mode,
+    options.verbose,
+  );
+
+  const args = [
+    ...(await sourcesArgs()).flat(),
+    ...getGlobalMocArgs(config),
+    ...migration.migrationArgs,
+    ...collectExtraArgs(
+      config,
+      canister,
+      canisterName,
+      options.managedFlags,
+      options.commandName,
+      options.extraArgs,
+    ),
+  ];
+
+  return { motokoPath, args, cleanup: migration.cleanup };
+}
+
+function collectExtraArgs(
+  config: Config,
+  canister: CanisterConfig,
+  canisterName: string,
+  managedFlags: Record<string, string>,
+  commandName: string,
+  extraArgs?: string[],
+): string[] {
+  const args: string[] = [];
+
+  if (config.build?.args) {
+    if (typeof config.build.args === "string") {
+      cliError(
+        `[build] config 'args' should be an array of strings in mops.toml config file`,
+      );
+    }
+    args.push(...config.build.args);
+  }
+  if (canister.args) {
+    validateCanisterArgs(canister, canisterName, config);
+    args.push(...canister.args);
+  }
+  if (extraArgs) {
+    args.push(...extraArgs);
+  }
+
+  const warned = new Set<string>();
+  for (const arg of args) {
+    const hint = managedFlags[arg];
+    if (hint && !warned.has(arg)) {
+      warned.add(arg);
+      console.warn(
+        chalk.yellow(
+          `Warning: '${arg}' in args for canister ${canisterName} may conflict with ${commandName} — ${hint}`,
+        ),
+      );
+    }
+  }
+
+  return args;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",
@@ -76,7 +76,7 @@
     "markdown-table": "3.0.4",
     "mdast-util-from-markdown": "2.0.2",
     "mdast-util-to-markdown": "2.1.2",
-    "minimatch": "10.2.4",
+    "minimatch": "10.2.5",
     "ncp": "2.0.0",
     "octokit": "3.1.2",
     "pem-file": "1.0.1",
@@ -90,7 +90,7 @@
     "semver": "7.7.1",
     "stream-to-promise": "3.0.0",
     "string-width": "7.2.0",
-    "tar": "7.5.11",
+    "tar": "7.5.16",
     "terminal-size": "4.0.0",
     "vscode-languageserver-textdocument": "1.0.12"
   },
@@ -106,13 +106,13 @@
     "@types/proper-lockfile": "4.1.4",
     "@types/semver": "7.5.8",
     "@types/stream-to-promise": "2.2.4",
-    "@types/tar": "6.1.13",
-    "esbuild": "0.23.1",
+    "@types/tar": "7.0.87",
+    "esbuild": "0.28.1",
     "eslint": "8.57.0",
     "npm-run-all": "4.1.5",
     "rexreplace": "7.1.13",
     "ts-jest": "29.4.5",
-    "tsx": "4.19.2",
+    "tsx": "4.22.4",
     "typescript": "5.9.2",
     "wasm-pack": "0.15.0"
   }

package/tests/__snapshots__/check-fix-utf8.test.ts.snap

@@ -0,0 +1,27 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`check --fix (utf-8 source) multi-byte characters do not corrupt the fix: fix output 1`] = `
+"Fixed run/multibyte.mo (3 fixes: M0236)
+
+✓ 3 fixes applied to 1 file
+✓ <TEST_DIR>/check/fix-utf8/run/multibyte.mo"
+`;
+
+exports[`check --fix (utf-8 source) multi-byte characters do not corrupt the fix: fixed file 1`] = `
+"// Regression fixture: --fix must apply byte-accurately when a multi-byte UTF-8
+// literal sits before the dot-notation span on the SAME line — that's where
+// moc's byte columns and LSP's UTF-16 positions diverge. Each body is a single
+// expression so prettier keeps it on one line (it splits \`;\`-separated
+// statements). \`Char.toNat32(c)\` triggers M0236; a column-based edit over-deletes
+// past the multi-byte prefix and drops the trailing \`)\`. Literal receivers are
+// avoided on purpose — moc no longer suggests dot-rewrites for them
+// (caffeinelabs/motoko#6173).
+import Char "mo:core/Char";
+
+module {
+  public func a(c : Char) : Text = "A" # debug_show (c.toNat32());
+  public func b(c : Char) : Text = "京" # debug_show (c.toNat32());
+  public func d(c : Char) : Text = "💩" # debug_show (c.toNat32());
+};
+"
+`;

package/tests/__snapshots__/deployed.test.ts.snap

@@ -0,0 +1,10 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`deployed init creates baseline .most and sets [check-stable].path 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "✓ Created baseline deployed/backend.most
+✓ Set [canisters.backend.check-stable].path = "deployed/backend.most"",
+}
+`;

package/tests/__snapshots__/generate.test.ts.snap

@@ -0,0 +1,39 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`generate candid configured path: overwrites in place and does not touch mops.toml 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "generate candid bar → candid/bar.did
+
+✓ Generated Candid for 1 canister",
+}
+`;
+
+exports[`generate candid default path: writes <main-dir>/<name>.did and sets [canisters.<name>].candid 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "generate candid foo → src/foo.did
+
+✓ Generated Candid for 1 canister",
+}
+`;
+
+exports[`generate candid default path: writes <main-dir>/<name>.did and sets [canisters.<name>].candid: src/foo.did 1`] = `
+"service : {
+  call: () -> (text);
+}
+"
+`;
+
+exports[`generate candid no canister names: processes all canisters 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "generate candid foo → src/foo.did
+generate candid bar → candid/bar.did
+
+✓ Generated Candid for 2 canisters",
+}
+`;

package/tests/check/fix-utf8/mops.toml

@@ -0,0 +1,5 @@
+[dependencies]
+core = "2.0.0"
+
+[toolchain]
+moc = "1.10.0"

package/tests/check/fix-utf8/multibyte.mo

@@ -0,0 +1,15 @@
+// Regression fixture: --fix must apply byte-accurately when a multi-byte UTF-8
+// literal sits before the dot-notation span on the SAME line — that's where
+// moc's byte columns and LSP's UTF-16 positions diverge. Each body is a single
+// expression so prettier keeps it on one line (it splits `;`-separated
+// statements). `Char.toNat32(c)` triggers M0236; a column-based edit over-deletes
+// past the multi-byte prefix and drops the trailing `)`. Literal receivers are
+// avoided on purpose — moc no longer suggests dot-rewrites for them
+// (caffeinelabs/motoko#6173).
+import Char "mo:core/Char";
+
+module {
+  public func a(c : Char) : Text = "A" # debug_show (Char.toNat32(c));
+  public func b(c : Char) : Text = "京" # debug_show (Char.toNat32(c));
+  public func d(c : Char) : Text = "💩" # debug_show (Char.toNat32(c));
+};

package/tests/check-fix-utf8.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test, beforeAll } from "@jest/globals";
+import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import path from "path";
+import { cli, normalizePaths } from "./helpers";
+
+// Regression: --fix must apply byte-accurately on UTF-8 source. The fixture
+// pins a moc version that emits `byte_start`/`byte_end` so the byte path is
+// exercised; without those fields the fixer over-deletes on multi-byte lines
+// (e.g. `Char.toNat32(c)` after a `"京"` on the same line losing its `)`).
+describe("check --fix (utf-8 source)", () => {
+  const fixDir = path.join(import.meta.dirname, "check/fix-utf8");
+  const runDir = path.join(fixDir, "run");
+  const warningFlags = "-W=M0236";
+
+  beforeAll(() => {
+    for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
+      unlinkSync(path.join(runDir, file));
+    }
+  });
+
+  test("multi-byte characters do not corrupt the fix", async () => {
+    const src = "multibyte.mo";
+    const runFilePath = path.join(runDir, src);
+    cpSync(path.join(fixDir, src), runFilePath);
+
+    const fixResult = await cli(
+      ["check", runFilePath, "--fix", "--", warningFlags],
+      { cwd: fixDir },
+    );
+
+    expect(normalizePaths(fixResult.stdout)).toMatchSnapshot("fix output");
+    const fixedContent = readFileSync(runFilePath, "utf-8");
+    expect(fixedContent).toMatchSnapshot("fixed file");
+
+    // Concrete byte-accuracy assertions: every Char.toNat32 call must be
+    // rewritten to dot notation, with the multi-byte literal before it intact
+    // and the trailing `)` preserved (the original regression: 京/💩 used to
+    // drop it).
+    expect(fixedContent).toContain('"A" # debug_show (c.toNat32());');
+    expect(fixedContent).toContain('"京" # debug_show (c.toNat32());');
+    expect(fixedContent).toContain('"💩" # debug_show (c.toNat32());');
+    expect(fixedContent).not.toMatch(/debug_show \(Char\.toNat32/);
+
+    // Verify no remaining M0236 warnings.
+    const afterResult = await cli(
+      ["check", runFilePath, "--", warningFlags, "--error-format=json"],
+      { cwd: fixDir },
+    );
+    expect(afterResult.stdout).not.toContain('"code":"M0236"');
+  });
+});

package/tests/check.test.ts

@@ -171,4 +171,28 @@ describe("check", () => {
     expect(result.exitCode).toBe(0);
     expect(result.stdout).toMatch(/✓ Lint fixes applied/);
   });
+
+  // The migrations-chain fixture has 4 migrations with check-limit=3, so the
+  // oldest is trimmed by default (staged dir + M0254 suppression). --no-check-limit
+  // must point moc at the real chain dir and drop the trimming side effects.
+  const migrationsChain = "check-stable/migrations-chain";
+
+  test("check-limit trims the migration chain by default", async () => {
+    const cwd = path.join(import.meta.dirname, migrationsChain);
+    const result = await cli(["check", "--verbose"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/--enhanced-migration=[^"]*\.migrations-/);
+    expect(result.stdout).toMatch(/-A=M0254/);
+  });
+
+  test("--no-check-limit uses the full migration chain", async () => {
+    const cwd = path.join(import.meta.dirname, migrationsChain);
+    const result = await cli(["check", "--verbose", "--no-check-limit"], {
+      cwd,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/--enhanced-migration=/);
+    expect(result.stdout).not.toMatch(/\.migrations-/);
+    expect(result.stdout).not.toMatch(/-A=M0254/);
+  });
 });

package/tests/deployed/basic/main.mo

@@ -0,0 +1,4 @@
+actor {
+  stable var counter : Nat = 0;
+  stable var name : Text = "";
+};

package/tests/deployed/basic/mops.toml

@@ -0,0 +1,8 @@
+[toolchain]
+moc = "1.5.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "main.mo"

package/tests/deployed/multi/bar.mo

@@ -0,0 +1 @@
+actor { stable var y : Text = "" };

package/tests/deployed/multi/foo.mo

@@ -0,0 +1 @@
+actor { stable var x : Nat = 0 };

package/tests/deployed/multi/mops.toml

@@ -0,0 +1,11 @@
+[toolchain]
+moc = "1.5.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.foo]
+main = "foo.mo"
+
+[canisters.bar]
+main = "bar.mo"

package/tests/deployed.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, test } from "@jest/globals";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { cli, normalizePaths, useTempFixtures } from "./helpers";
+
+describe("deployed", () => {
+  const makeTempFixture = useTempFixtures(
+    path.join(import.meta.dirname, "deployed"),
+  );
+
+  describe("init", () => {
+    test("creates baseline .most and sets [check-stable].path", async () => {
+      const cwd = await makeTempFixture("basic");
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+
+      const baseline = path.join(cwd, "deployed", "backend.most");
+      expect(existsSync(baseline)).toBe(true);
+      expect(readFileSync(baseline, "utf-8")).toBe(
+        "// Version: 1.0.0\nactor { };\n",
+      );
+
+      const toml = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+      expect(toml).toMatch(/\[canisters\.backend\.check-stable\]/);
+      expect(toml).toMatch(/path\s*=\s*"deployed\/backend\.most"/);
+
+      expect({
+        exitCode: result.exitCode,
+        stdout: normalizePaths(result.stdout),
+        stderr: normalizePaths(result.stderr),
+      }).toMatchSnapshot();
+    });
+
+    test("idempotent — second run is a no-op", async () => {
+      const cwd = await makeTempFixture("basic");
+      await cli(["deployed", "init"], { cwd });
+      const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+
+      const tomlAfter = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+      expect(tomlAfter).toBe(tomlBefore);
+    });
+
+    test("warns when [check-stable].path is set elsewhere", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      const toml = readFileSync(tomlPath, "utf-8");
+      await writeFile(
+        tomlPath,
+        toml +
+          '\n[canisters.backend.check-stable]\npath = "elsewhere/backend.most"\n',
+      );
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toMatch(
+        /check-stable\]\.path = "elsewhere\/backend\.most"/,
+      );
+      expect(result.stderr).toMatch(/does not match where `mops deployed`/);
+      expect(existsSync(path.join(cwd, "deployed", "backend.most"))).toBe(true);
+
+      // mops.toml should not have been rewritten
+      expect(readFileSync(tomlPath, "utf-8")).toBe(
+        toml +
+          '\n[canisters.backend.check-stable]\npath = "elsewhere/backend.most"\n',
+      );
+    });
+
+    test("respects [deployed].dir", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      const toml = readFileSync(tomlPath, "utf-8");
+      await writeFile(tomlPath, `${toml}\n[deployed]\ndir = "snapshots"\n`);
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, "snapshots", "backend.most"))).toBe(
+        true,
+      );
+      expect(readFileSync(tomlPath, "utf-8")).toMatch(
+        /path\s*=\s*"snapshots\/backend\.most"/,
+      );
+    });
+
+    test("init for shorthand canister entry promotes it to a table", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      await writeFile(
+        tomlPath,
+        '[toolchain]\nmoc = "1.5.0"\n\n[canisters]\nbackend = "main.mo"\n',
+      );
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+
+      const after = readFileSync(tomlPath, "utf-8");
+      expect(after).toMatch(/\[canisters\.backend\]/);
+      expect(after).toMatch(/main\s*=\s*"main\.mo"/);
+      expect(after).toMatch(/\[canisters\.backend\.check-stable\]/);
+      expect(after).toMatch(/path\s*=\s*"deployed\/backend\.most"/);
+    });
+
+    test("errors on unknown canister name", async () => {
+      const cwd = await makeTempFixture("basic");
+      const result = await cli(["deployed", "init", "ghost"], { cwd });
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toMatch(/not found in mops\.toml/);
+    });
+
+    test("preserves an existing baseline file when wiring [check-stable].path", async () => {
+      const cwd = await makeTempFixture("basic");
+      const baseline = path.join(cwd, "deployed", "backend.most");
+      const customMost =
+        "// Version: 1.0.0\nactor {\n  stable var x : Nat\n};\n";
+      // pre-create the baseline (e.g. real prod snapshot copied in by the user)
+      await mkdir(path.join(cwd, "deployed"), { recursive: true });
+      await writeFile(baseline, customMost);
+
+      const result = await cli(["deployed", "init"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(readFileSync(baseline, "utf-8")).toBe(customMost);
+      expect(readFileSync(path.join(cwd, "mops.toml"), "utf-8")).toMatch(
+        /\[canisters\.backend\.check-stable\][\s\S]*path\s*=\s*"deployed\/backend\.most"/,
+      );
+    });
+  });
+
+  describe("post-deploy hook", () => {
+    test("copies built .most into deployed/", async () => {
+      const cwd = await makeTempFixture("basic");
+      const buildResult = await cli(["build"], { cwd });
+      expect(buildResult.exitCode).toBe(0);
+
+      const result = await cli(["deployed"], { cwd });
+      expect(result.exitCode).toBe(0);
+
+      const built = path.join(cwd, ".mops", ".build", "backend.most");
+      const promoted = path.join(cwd, "deployed", "backend.most");
+      expect(existsSync(promoted)).toBe(true);
+      expect(readFileSync(promoted, "utf-8")).toBe(
+        readFileSync(built, "utf-8"),
+      );
+    });
+
+    test("errors when source .most is missing", async () => {
+      const cwd = await makeTempFixture("basic");
+      const result = await cli(["deployed", "backend"], { cwd });
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toMatch(/No built \.most/);
+      expect(result.stderr).toMatch(/Run `mops build backend` first/);
+    });
+
+    test("warns when [check-stable].path differs from <dir>/<name>.most", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      const toml = readFileSync(tomlPath, "utf-8");
+      await writeFile(
+        tomlPath,
+        toml +
+          '\n[canisters.backend.check-stable]\npath = "elsewhere/backend.most"\n',
+      );
+
+      const buildResult = await cli(["build"], { cwd });
+      expect(buildResult.exitCode).toBe(0);
+
+      const result = await cli(["deployed"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toMatch(
+        /check-stable\]\.path = "elsewhere\/backend\.most"/,
+      );
+      expect(result.stderr).toMatch(/won't see updates from `mops deployed`/);
+    });
+
+    test("respects [deployed].dir from config", async () => {
+      const cwd = await makeTempFixture("basic");
+      const tomlPath = path.join(cwd, "mops.toml");
+      const toml = readFileSync(tomlPath, "utf-8");
+      await writeFile(tomlPath, `${toml}\n[deployed]\ndir = "snapshots"\n`);
+
+      await cli(["build"], { cwd });
+      const result = await cli(["deployed"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, "snapshots", "backend.most"))).toBe(
+        true,
+      );
+      expect(existsSync(path.join(cwd, "deployed", "backend.most"))).toBe(
+        false,
+      );
+    });
+
+    test("--build-dir and --dir overrides", async () => {
+      const cwd = await makeTempFixture("basic");
+      const customOut = "custom-build";
+      const customDir = "snapshots";
+
+      const buildResult = await cli(
+        ["build", "backend", "--output", customOut],
+        { cwd },
+      );
+      expect(buildResult.exitCode).toBe(0);
+
+      const result = await cli(
+        ["deployed", "--build-dir", customOut, "--dir", customDir],
+        { cwd },
+      );
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, customDir, "backend.most"))).toBe(true);
+    });
+
+    test("with no canister names promotes all canisters", async () => {
+      const cwd = await makeTempFixture("multi");
+      const buildResult = await cli(["build"], { cwd });
+      expect(buildResult.exitCode).toBe(0);
+
+      const result = await cli(["deployed"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, "deployed", "foo.most"))).toBe(true);
+      expect(existsSync(path.join(cwd, "deployed", "bar.most"))).toBe(true);
+    });
+
+    test("named canister filters to that canister only", async () => {
+      const cwd = await makeTempFixture("multi");
+      await cli(["build"], { cwd });
+
+      const result = await cli(["deployed", "foo"], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(path.join(cwd, "deployed", "foo.most"))).toBe(true);
+      expect(existsSync(path.join(cwd, "deployed", "bar.most"))).toBe(false);
+    });
+  });
+
+  describe("end-to-end with check-stable", () => {
+    test("init + build + deployed wires the check-stable baseline", async () => {
+      const cwd = await makeTempFixture("basic");
+
+      await cli(["deployed", "init"], { cwd });
+      await cli(["build"], { cwd });
+      const promoteResult = await cli(["deployed"], { cwd });
+      expect(promoteResult.exitCode).toBe(0);
+
+      const checkResult = await cli(["check-stable"], { cwd });
+      expect(checkResult.exitCode).toBe(0);
+      expect(checkResult.stdout).toMatch(/Stable compatibility check passed/);
+    });
+  });
+});

package/tests/generate/basic/candid/bar.did

@@ -0,0 +1,4 @@
+// Hand-curated; will be overwritten by `mops generate candid bar`.
+service : {
+  greet: (text) -> (text);
+}

package/tests/generate/basic/mops.toml

@@ -0,0 +1,12 @@
+[toolchain]
+moc = "1.5.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.foo]
+main = "src/Foo.mo"
+
+[canisters.bar]
+main = "src/Bar.mo"
+candid = "candid/bar.did"

package/tests/generate/basic/src/Bar.mo

@@ -0,0 +1,5 @@
+persistent actor {
+  public func greet(name : Text) : async Text {
+    "Hello, " # name;
+  };
+};

package/tests/generate/basic/src/Foo.mo

@@ -0,0 +1,5 @@
+persistent actor {
+  public func call() : async Text {
+    "Foo";
+  };
+};

package/tests/generate/error/mops.toml

@@ -0,0 +1,8 @@
+[toolchain]
+moc = "1.5.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.broken]
+main = "src/Broken.mo"