ic-mops 2.15.1 → 2.16.0

package/dist/helpers/get-lintoko-version.js

@@ -0,0 +1,30 @@
+import { execFileSync } from "node:child_process";
+import { parse } from "semver";
+import { FILE_PATH_REGEX } from "../constants.js";
+import { readConfig } from "../mops.js";
+export function getLintokoSemVer() {
+    return parse(getLintokoVersion(false));
+}
+export function getLintokoVersion(throwOnError = false) {
+    let configVersion = readConfig().toolchain?.lintoko;
+    if (!configVersion) {
+        return "";
+    }
+    if (!configVersion.match(FILE_PATH_REGEX)) {
+        return configVersion;
+    }
+    try {
+        let match = execFileSync(configVersion, ["--version"])
+            .toString()
+            .trim()
+            .match(/lintoko ([^\s]+)/);
+        return match?.[1] || "";
+    }
+    catch (e) {
+        if (throwOnError) {
+            console.error(e);
+            throw new Error("lintoko not found");
+        }
+        return "";
+    }
+}

package/dist/helpers/migrations.d.ts

@@ -8,6 +8,22 @@ export declare function getNextMigrationFile(nextDir: string): string | null;
 export declare function validateNextMigrationOrder(chainDirOrFiles: string | string[], nextFile: string): void;
 export declare function validateMigrationsConfig(migrations: MigrationsConfig, canisterName: string): void;
 export declare function prepareMigrationArgs(migrations: MigrationsConfig | undefined, canisterName: string, mode: "check" | "build", verbose?: boolean, ignoreLimit?: boolean): Promise<MigrationArgsResult>;
+/**
+ * Local chain (+ next) files not yet recorded in the deployed `.most` baseline.
+ */
+export declare function getPendingMigrationFiles(migrations: MigrationsConfig, canisterName: string, appliedNames: string[]): string[];
+/**
+ * Pending migrations exceed `check-limit` relative to the deployed `.most` baseline.
+ */
+export interface CheckLimitPendingIssue {
+    canisterName: string;
+    pending: string[];
+    checkLimit: number;
+    latestApplied: string | null;
+}
+export declare function getCheckLimitPendingIssue(migrations: MigrationsConfig | undefined, canisterName: string, oldMostPath: string, ignoreCheckLimit: boolean, baselineIsMostFile: boolean): CheckLimitPendingIssue | null;
+/** Warn on accidental compat pass; fail with this diagnostic when compat already failed. */
+export declare function reportCheckLimitPendingIssue(issue: CheckLimitPendingIssue, compatFailed: boolean): void;
 /**
  * Absolute paths of chain migration files that `mops lint` should skip,
  * mirroring the `check-limit` trimming applied to `moc` during `mops check`.

package/dist/helpers/migrations.js

@@ -1,10 +1,11 @@
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, symlinkSync, writeFileSync, } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, symlinkSync, writeFileSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { rm } from "node:fs/promises";
 import chalk from "chalk";
 import { cliError } from "../error.js";
 import { getRootDir, resolveConfigPath } from "../mops.js";
 import { resolveCanisterConfigs } from "./resolve-canisters.js";
+import { latestAppliedMigrationName, migrationBasename, parseMostAppliedMigrationNames, } from "./parse-most.js";
 function stagedMigrationsDir(chainDir, canisterName) {
     return join(dirname(chainDir), `.migrations-${canisterName}`);
 }
@@ -151,6 +152,75 @@ export async function prepareMigrationArgs(migrations, canisterName, mode, verbo
         },
     };
 }
+/**
+ * Local chain (+ next) files not yet recorded in the deployed `.most` baseline.
+ */
+export function getPendingMigrationFiles(migrations, canisterName, appliedNames) {
+    validateMigrationsConfig(migrations, canisterName);
+    const chainDir = resolveConfigPath(migrations.chain);
+    const nextDir = migrations.next
+        ? resolveConfigPath(migrations.next)
+        : undefined;
+    const nextFile = nextDir ? getNextMigrationFile(nextDir) : null;
+    const all = getMigrationFiles(chainDir);
+    if (nextFile) {
+        all.push(nextFile);
+    }
+    const highWaterMark = appliedNames.length > 0 ? latestAppliedMigrationName(appliedNames) : "";
+    return all.filter((file) => migrationBasename(file) > highWaterMark);
+}
+export function getCheckLimitPendingIssue(migrations, canisterName, oldMostPath, ignoreCheckLimit, baselineIsMostFile) {
+    if (!migrations || ignoreCheckLimit || !baselineIsMostFile) {
+        return null;
+    }
+    const checkLimit = migrations["check-limit"];
+    if (checkLimit === undefined) {
+        return null;
+    }
+    let appliedNames;
+    try {
+        appliedNames = parseMostAppliedMigrationNames(readFileSync(oldMostPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (appliedNames === null) {
+        return null;
+    }
+    const pending = getPendingMigrationFiles(migrations, canisterName, appliedNames);
+    if (pending.length <= checkLimit) {
+        return null;
+    }
+    return {
+        canisterName,
+        pending,
+        checkLimit,
+        latestApplied: appliedNames.length > 0 ? latestAppliedMigrationName(appliedNames) : null,
+    };
+}
+function formatCheckLimitPendingLines(issue) {
+    const { canisterName, pending, checkLimit } = issue;
+    return [
+        `Canister '${canisterName}' has ${pending.length} pending migration(s) but check-limit=${checkLimit}. ` +
+            `Fold all changes into the latest pending migration: ${pending[pending.length - 1]}`,
+        `  Pending: ${pending.join(", ")}`,
+        ...(issue.latestApplied
+            ? [`  Latest already applied migration: ${issue.latestApplied}`]
+            : []),
+    ];
+}
+/** Warn on accidental compat pass; fail with this diagnostic when compat already failed. */
+export function reportCheckLimitPendingIssue(issue, compatFailed) {
+    const lines = formatCheckLimitPendingLines(issue);
+    if (compatFailed) {
+        cliError(`✗ Stable compatibility check failed for canister '${issue.canisterName}': too many pending migrations for check-limit=${issue.checkLimit}\n` +
+            lines.join("\n"));
+    }
+    console.warn(chalk.yellow(`WARN: ${lines[0]}`));
+    for (const line of lines.slice(1)) {
+        console.warn(chalk.yellow(line));
+    }
+}
 /**
  * Absolute paths of chain migration files that `mops lint` should skip,
  * mirroring the `check-limit` trimming applied to `moc` during `mops check`.

package/dist/helpers/parse-most.d.ts

@@ -0,0 +1,5 @@
+/** Enhanced-migration names recorded in a Version 4.0.0 `.most` chain block. */
+export declare function parseMostAppliedMigrationNames(content: string): string[] | null;
+export declare function migrationBasename(file: string): string;
+/** Lexicographic max of applied migration names (matches chain file sort order). */
+export declare function latestAppliedMigrationName(appliedNames: string[]): string;

package/dist/helpers/parse-most.js

@@ -0,0 +1,28 @@
+/** Enhanced-migration names recorded in a Version 4.0.0 `.most` chain block. */
+export function parseMostAppliedMigrationNames(content) {
+    const version = content.match(/^\/\/ Version: ([^\n]+)/m)?.[1]?.trim();
+    if (!version) {
+        return null;
+    }
+    if (version !== "4.0.0") {
+        return [];
+    }
+    // Safe: actor types in type aliases are always indented (col ≥ 2); the main actor is at col 0.
+    const actorIdx = content.search(/\nactor\b/);
+    if (actorIdx < 0) {
+        return null;
+    }
+    const chainBlock = content.slice(0, actorIdx);
+    const names = [];
+    for (const match of chainBlock.matchAll(/[{;]\s*"([^"]+)"\s*:/gs)) {
+        names.push(match[1]);
+    }
+    return names;
+}
+export function migrationBasename(file) {
+    return file.endsWith(".mo") ? file.slice(0, -3) : file;
+}
+/** Lexicographic max of applied migration names (matches chain file sort order). */
+export function latestAppliedMigrationName(appliedNames) {
+    return appliedNames.reduce((max, name) => (name > max ? name : max), "");
+}

package/dist/mops.js

@@ -177,9 +177,9 @@ export function readConfig(configFile = getClosestConfigFile()) {
     processDeps(toml["dev-dependencies"] || {});
     let config = { ...toml };
     Object.entries(config.requirements || {}).forEach(([name, value]) => {
-        if (name === "moc") {
+        if (name === "moc" || name === "lintoko") {
             config.requirements = config.requirements || {};
-            config.requirements.moc = value;
+            config.requirements[name] = value;
         }
     });
     return config;

package/dist/package.json

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

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

@@ -94,4 +94,19 @@ describe("check-stable", () => {
             expect(result.stdout).toMatch(/Stable compatibility check passed/);
         }
     }, 60_000);
+    test("fails with check-limit diagnostic when pending migrations exceed check-limit", async () => {
+        const cwd = path.join(import.meta.dirname, "check-stable/check-limit-warning");
+        await cliSnapshot(["check-stable"], { cwd }, 1);
+    });
+    test("does not warn when deployed baseline matches the chain", async () => {
+        const cwd = path.join(import.meta.dirname, "check-stable/migrations-chain");
+        const result = await cli(["check-stable"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stderr).not.toMatch(/pending migration\(s\) but check-limit/);
+    });
+    test("--no-check-limit suppresses pending migration warning", async () => {
+        const cwd = path.join(import.meta.dirname, "check-stable/check-limit-warning");
+        const result = await cli(["check-stable", "--no-check-limit"], { cwd });
+        expect(result.stderr).not.toMatch(/pending migration\(s\) but check-limit/);
+    });
 });

package/dist/tests/check.test.js

@@ -158,4 +158,9 @@ describe("check", () => {
         expect(result.stdout).not.toMatch(/\.migrations-/);
         expect(result.stdout).not.toMatch(/-A=M0254/);
     });
+    test("--no-check-limit suppresses pending migration warning in check", async () => {
+        const cwd = path.join(import.meta.dirname, "check-stable/check-limit-warning");
+        const result = await cli(["check", "--no-check-limit"], { cwd });
+        expect(result.stderr).not.toMatch(/pending migration\(s\) but check-limit/);
+    });
 });

package/dist/tests/lint.test.js

@@ -68,7 +68,7 @@ describe("lint", () => {
             const cwd = path.join(import.meta.dirname, "lint-extra-with-cli-rules");
             await cliSnapshot(["lint", "--rules", "empty-rules", "--verbose"], { cwd }, 1);
         });
-        test("example rules: no-types, types-only, migration-only", async () => {
+        test("example rules: no-types, types-only, migration-only, migration-self-contained", async () => {
             const cwd = path.join(import.meta.dirname, "lint-extra-example-rules");
             await cliSnapshot(["lint"], { cwd }, 1);
         });

package/dist/tests/migrations-most.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/migrations-most.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "@jest/globals";
+import { latestAppliedMigrationName, parseMostAppliedMigrationNames, } from "../helpers/parse-most";
+describe("parseMostAppliedMigrationNames", () => {
+    test("parses Version 4.0.0 enhanced-migration chain", () => {
+        const content = `// Version: 4.0.0
+{
+  "20250101_000000_Init" : {} -> {a : Nat; b : Text};
+  "20250201_000000_AddField" : (old : {a : Nat; b : Text}) -> {a : Nat; b : Text; c : Bool};
+}
+actor  {
+  stable a : Nat;
+  stable b : Text;
+  stable c : Bool
+};
+`;
+        expect(parseMostAppliedMigrationNames(content)).toEqual([
+            "20250101_000000_Init",
+            "20250201_000000_AddField",
+        ]);
+    });
+    test("returns empty array for Version 1.0.0 (no EM chain)", () => {
+        expect(parseMostAppliedMigrationNames("// Version: 1.0.0\nactor { };\n")).toEqual([]);
+    });
+    test("returns empty array for Version 3.0.0 (legacy migration)", () => {
+        const content = `// Version: 3.0.0
+actor ({
+}, {
+  stable var field1 : Nat;
+  stable var field2 : Text
+});
+`;
+        expect(parseMostAppliedMigrationNames(content)).toEqual([]);
+    });
+    test("returns null when version header is missing", () => {
+        expect(parseMostAppliedMigrationNames("actor { };\n")).toBeNull();
+    });
+    test("returns null when Version 4.0.0 has no actor block", () => {
+        expect(parseMostAppliedMigrationNames('// Version: 4.0.0\n{ "Init" : {} -> {} }')).toBeNull();
+    });
+    test("latestAppliedMigrationName picks lexicographic max", () => {
+        expect(latestAppliedMigrationName([
+            "20250101_000000_Init",
+            "20250301_000000_AddD",
+            "20250201_000000_AddField",
+        ])).toBe("20250301_000000_AddD");
+    });
+});

package/dist/tests/requirements.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/requirements.test.js

@@ -0,0 +1,46 @@
+import { describe, expect, test, beforeEach, afterEach } from "@jest/globals";
+import { cp, mkdir, rm, writeFile } from "node:fs/promises";
+import path from "path";
+import { bytesToHex } from "@noble/hashes/utils";
+import { sha256 } from "@noble/hashes/sha256";
+import { cli } from "./helpers";
+describe("requirements", () => {
+    const fixtureDir = path.join(import.meta.dirname, "requirements-lintoko");
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = path.join(import.meta.dirname, `_tmp_requirements_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`);
+        await cp(fixtureDir, tempDir, { recursive: true });
+        const depDir = path.join(tempDir, ".mops", "my-pkg@0.1.0");
+        await mkdir(depDir, { recursive: true });
+        await writeFile(path.join(depDir, "mops.toml"), `[package]
+name = "my-pkg"
+version = "0.1.0"
+
+[requirements]
+lintoko = "0.10.0"
+`);
+        const mopsTomlDepsHash = bytesToHex(sha256(JSON.stringify({ "my-pkg": "0.1.0" })));
+        await writeFile(path.join(tempDir, "mops.lock"), JSON.stringify({
+            version: 3,
+            mopsTomlDepsHash,
+            deps: { "my-pkg": "0.1.0" },
+            hashes: {
+                "my-pkg@0.1.0": {
+                    "mops.toml": "0000000000000000000000000000000000000000000000000000000000000000",
+                },
+            },
+        }));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    test("lintoko requirement warns when installed version is too old", async () => {
+        const result = await cli(["toolchain", "use", "lintoko", "0.7.0"], {
+            cwd: tempDir,
+        });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/lintoko version does not meet the requirements of my-pkg@0\.1\.0/);
+        expect(result.stdout).toMatch(/Required: >= 0\.10\.0/);
+        expect(result.stdout).toMatch(/Installed:\s+0\.7\.0/);
+    });
+});

package/dist/types.d.ts

@@ -71,5 +71,6 @@ export type Toolchain = {
 export type Tool = "moc" | "wasmtime" | "pocket-ic" | "lintoko";
 export type Requirements = {
     moc?: string;
+    lintoko?: string;
 };
 export type TestMode = "interpreter" | "wasi" | "replica";

package/helpers/get-lintoko-version.ts

@@ -0,0 +1,32 @@
+import { execFileSync } from "node:child_process";
+import { type SemVer, parse } from "semver";
+import { FILE_PATH_REGEX } from "../constants.js";
+import { readConfig } from "../mops.js";
+
+export function getLintokoSemVer(): SemVer | null {
+  return parse(getLintokoVersion(false));
+}
+
+export function getLintokoVersion(throwOnError = false): string {
+  let configVersion = readConfig().toolchain?.lintoko;
+  if (!configVersion) {
+    return "";
+  }
+  if (!configVersion.match(FILE_PATH_REGEX)) {
+    return configVersion;
+  }
+
+  try {
+    let match = execFileSync(configVersion, ["--version"])
+      .toString()
+      .trim()
+      .match(/lintoko ([^\s]+)/);
+    return match?.[1] || "";
+  } catch (e) {
+    if (throwOnError) {
+      console.error(e);
+      throw new Error("lintoko not found");
+    }
+    return "";
+  }
+}

package/helpers/migrations.ts

@@ -2,6 +2,7 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
+  readFileSync,
   readdirSync,
   symlinkSync,
   writeFileSync,
@@ -13,6 +14,11 @@ import { cliError } from "../error.js";
 import { getRootDir, resolveConfigPath } from "../mops.js";
 import { resolveCanisterConfigs } from "./resolve-canisters.js";
 import { Config, MigrationsConfig } from "../types.js";
+import {
+  latestAppliedMigrationName,
+  migrationBasename,
+  parseMostAppliedMigrationNames,
+} from "./parse-most.js";
 
 function stagedMigrationsDir(chainDir: string, canisterName: string): string {
   return join(dirname(chainDir), `.migrations-${canisterName}`);
@@ -234,6 +240,117 @@ export async function prepareMigrationArgs(
   };
 }
 
+/**
+ * Local chain (+ next) files not yet recorded in the deployed `.most` baseline.
+ */
+export function getPendingMigrationFiles(
+  migrations: MigrationsConfig,
+  canisterName: string,
+  appliedNames: string[],
+): string[] {
+  validateMigrationsConfig(migrations, canisterName);
+
+  const chainDir = resolveConfigPath(migrations.chain);
+  const nextDir = migrations.next
+    ? resolveConfigPath(migrations.next)
+    : undefined;
+  const nextFile = nextDir ? getNextMigrationFile(nextDir) : null;
+
+  const all = getMigrationFiles(chainDir);
+  if (nextFile) {
+    all.push(nextFile);
+  }
+
+  const highWaterMark =
+    appliedNames.length > 0 ? latestAppliedMigrationName(appliedNames) : "";
+  return all.filter((file) => migrationBasename(file) > highWaterMark);
+}
+
+/**
+ * Pending migrations exceed `check-limit` relative to the deployed `.most` baseline.
+ */
+export interface CheckLimitPendingIssue {
+  canisterName: string;
+  pending: string[];
+  checkLimit: number;
+  latestApplied: string | null;
+}
+
+export function getCheckLimitPendingIssue(
+  migrations: MigrationsConfig | undefined,
+  canisterName: string,
+  oldMostPath: string,
+  ignoreCheckLimit: boolean,
+  baselineIsMostFile: boolean,
+): CheckLimitPendingIssue | null {
+  if (!migrations || ignoreCheckLimit || !baselineIsMostFile) {
+    return null;
+  }
+  const checkLimit = migrations["check-limit"];
+  if (checkLimit === undefined) {
+    return null;
+  }
+
+  let appliedNames: string[] | null;
+  try {
+    appliedNames = parseMostAppliedMigrationNames(
+      readFileSync(oldMostPath, "utf8"),
+    );
+  } catch {
+    return null;
+  }
+  if (appliedNames === null) {
+    return null;
+  }
+
+  const pending = getPendingMigrationFiles(
+    migrations,
+    canisterName,
+    appliedNames,
+  );
+  if (pending.length <= checkLimit) {
+    return null;
+  }
+
+  return {
+    canisterName,
+    pending,
+    checkLimit,
+    latestApplied:
+      appliedNames.length > 0 ? latestAppliedMigrationName(appliedNames) : null,
+  };
+}
+
+function formatCheckLimitPendingLines(issue: CheckLimitPendingIssue): string[] {
+  const { canisterName, pending, checkLimit } = issue;
+  return [
+    `Canister '${canisterName}' has ${pending.length} pending migration(s) but check-limit=${checkLimit}. ` +
+      `Fold all changes into the latest pending migration: ${pending[pending.length - 1]}`,
+    `  Pending: ${pending.join(", ")}`,
+    ...(issue.latestApplied
+      ? [`  Latest already applied migration: ${issue.latestApplied}`]
+      : []),
+  ];
+}
+
+/** Warn on accidental compat pass; fail with this diagnostic when compat already failed. */
+export function reportCheckLimitPendingIssue(
+  issue: CheckLimitPendingIssue,
+  compatFailed: boolean,
+): void {
+  const lines = formatCheckLimitPendingLines(issue);
+  if (compatFailed) {
+    cliError(
+      `✗ Stable compatibility check failed for canister '${issue.canisterName}': too many pending migrations for check-limit=${issue.checkLimit}\n` +
+        lines.join("\n"),
+    );
+  }
+  console.warn(chalk.yellow(`WARN: ${lines[0]}`));
+  for (const line of lines.slice(1)) {
+    console.warn(chalk.yellow(line));
+  }
+}
+
 /**
  * Absolute paths of chain migration files that `mops lint` should skip,
  * mirroring the `check-limit` trimming applied to `moc` during `mops check`.

package/helpers/parse-most.ts

@@ -0,0 +1,32 @@
+/** Enhanced-migration names recorded in a Version 4.0.0 `.most` chain block. */
+export function parseMostAppliedMigrationNames(
+  content: string,
+): string[] | null {
+  const version = content.match(/^\/\/ Version: ([^\n]+)/m)?.[1]?.trim();
+  if (!version) {
+    return null;
+  }
+  if (version !== "4.0.0") {
+    return [];
+  }
+  // Safe: actor types in type aliases are always indented (col ≥ 2); the main actor is at col 0.
+  const actorIdx = content.search(/\nactor\b/);
+  if (actorIdx < 0) {
+    return null;
+  }
+  const chainBlock = content.slice(0, actorIdx);
+  const names: string[] = [];
+  for (const match of chainBlock.matchAll(/[{;]\s*"([^"]+)"\s*:/gs)) {
+    names.push(match[1]!);
+  }
+  return names;
+}
+
+export function migrationBasename(file: string): string {
+  return file.endsWith(".mo") ? file.slice(0, -3) : file;
+}
+
+/** Lexicographic max of applied migration names (matches chain file sort order). */
+export function latestAppliedMigrationName(appliedNames: string[]): string {
+  return appliedNames.reduce((max, name) => (name > max ? name : max), "");
+}

package/mops.ts

@@ -205,9 +205,9 @@ export function readConfig(configFile = getClosestConfigFile()): Config {
   let config: Config = { ...toml };
 
   Object.entries(config.requirements || {}).forEach(([name, value]) => {
-    if (name === "moc") {
+    if (name === "moc" || name === "lintoko") {
       config.requirements = config.requirements || {};
-      config.requirements.moc = value;
+      config.requirements[name] = value;
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.15.1",
+  "version": "2.16.0",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",

package/tests/__snapshots__/check-stable.test.ts.snap

@@ -8,6 +8,17 @@ exports[`check-stable compatible upgrade from .mo file 1`] = `
 }
 `;
 
+exports[`check-stable fails with check-limit diagnostic when pending migrations exceed check-limit 1`] = `
+{
+  "exitCode": 1,
+  "stderr": "✗ Stable compatibility check failed for canister 'backend': too many pending migrations for check-limit=1
+Canister 'backend' has 2 pending migration(s) but check-limit=1. Fold all changes into the latest pending migration: 20250301_000000_AddD.mo
+  Pending: 20250201_000000_AddField.mo, 20250301_000000_AddD.mo
+  Latest already applied migration: 20250101_000000_Init",
+  "stdout": "",
+}
+`;
+
 exports[`check-stable incompatible upgrade from .mo file 1`] = `
 {
   "exitCode": 1,

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

@@ -77,7 +77,7 @@ exports[`lint [lint.extra] edge cases: pass, empty value, no-match, missing dir
 }
 `;
 
-exports[`lint [lint.extra] example rules: no-types, types-only, migration-only 1`] = `
+exports[`lint [lint.extra] example rules: no-types, types-only, migration-only, migration-self-contained 1`] = `
 {
   "exitCode": 1,
   "stderr": "  × [ERROR]: no-types
@@ -114,6 +114,34 @@ Error: Found 1 errors
    ╰────
 
 Error: Found 1 errors
+  × [ERROR]: migration-self-contained
+   ╭─[<TEST_DIR>/lint-extra-example-rules/migrations/20250101_000000_Init.mo:3:14]
+ 2 │ import Backend "canister:backend";
+ 3 │ import Types "Types";
+   ·              ───┬───
+   ·                 ╰── Migration files must not import local modules (relative paths). Got: "Types"
+ 4 │ import TypesDot "./Types";
+   ╰────
+
+  × [ERROR]: migration-self-contained
+   ╭─[<TEST_DIR>/lint-extra-example-rules/migrations/20250101_000000_Init.mo:4:17]
+ 3 │ import Types "Types";
+ 4 │ import TypesDot "./Types";
+   ·                 ────┬────
+   ·                     ╰── Migration files must not import local modules (relative paths). Got: "./Types"
+ 5 │ import TypesParent "../src/Types";
+   ╰────
+
+  × [ERROR]: migration-self-contained
+   ╭─[<TEST_DIR>/lint-extra-example-rules/migrations/20250101_000000_Init.mo:5:20]
+ 4 │ import TypesDot "./Types";
+ 5 │ import TypesParent "../src/Types";
+   ·                    ───────┬──────
+   ·                           ╰── Migration files must not import local modules (relative paths). Got: "../src/Types"
+ 6 │ 
+   ╰────
+
+Error: Found 3 errors
 Lint failed",
   "stdout": "",
 }

package/tests/check-stable/check-limit-warning/deployed.most

@@ -0,0 +1,8 @@
+// Version: 4.0.0
+{
+  "20250101_000000_Init" : {} -> {a : Nat; b : Text};
+}
+actor  {
+  stable a : Nat;
+  stable b : Text
+};

package/tests/check-stable/check-limit-warning/migrations/20250101_000000_Init.mo

@@ -0,0 +1,5 @@
+module {
+  public func migration(_ : {}) : { a : Nat; b : Text } {
+    { a = 42; b = "hello" };
+  };
+};

package/tests/check-stable/check-limit-warning/migrations/20250201_000000_AddField.mo

@@ -0,0 +1,9 @@
+module {
+  public func migration(old : { a : Nat; b : Text }) : {
+    a : Nat;
+    b : Text;
+    c : Bool;
+  } {
+    { old with c = true };
+  };
+};