ic-mops 2.15.0 → 2.15.2

package/dist/helpers/pocket-ic-client.js

@@ -1,18 +1,22 @@
 import semver from "semver";
-import { PocketIc, PocketIcServer } from "pic-ic";
-import { PocketIc as PocketIcModern, PocketIcServer as PocketIcServerModern, } from "pic-js-mops";
 import { readConfig } from "../mops.js";
 function isLegacy() {
     let version = readConfig().toolchain?.["pocket-ic"];
     return !!version && !!semver.valid(version) && semver.lt(version, "9.0.0");
 }
 export async function startPocketIc(options) {
+    // Imported lazily so commands that never start a replica don't load the
+    // PocketIC client. `pic-js-mops` ships ESM without `type: module`, which a
+    // static import fails to resolve under tsx (local dev); a dynamic import
+    // resolves it on every platform.
     if (isLegacy()) {
+        const { PocketIc, PocketIcServer } = await import("pic-ic");
         let server = await PocketIcServer.start(options);
         let client = await PocketIc.create(server.getUrl());
         return { server, client };
     }
-    let server = await PocketIcServerModern.start(options);
-    let client = await PocketIcModern.create(server.getUrl());
+    const { PocketIc, PocketIcServer } = await import("pic-js-mops");
+    let server = await PocketIcServer.start(options);
+    let client = await PocketIc.create(server.getUrl());
     return { server, client };
 }

package/dist/package.json

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

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

@@ -1,5 +1,5 @@
 import { beforeAll, describe, expect, test } from "@jest/globals";
-import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { chmodSync, cpSync, readdirSync, readFileSync, unlinkSync, } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "path";
 import { lock } from "proper-lockfile";
@@ -19,7 +19,9 @@ describe("check --fix", () => {
     const diagnosticFlags = [warningFlags, "--error-format=json"];
     beforeAll(() => {
         for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
-            unlinkSync(path.join(runDir, file));
+            const p = path.join(runDir, file);
+            chmodSync(p, 0o644);
+            unlinkSync(p);
         }
     });
     function copyFixture(file) {
@@ -86,6 +88,16 @@ describe("check --fix", () => {
         expect(fixResult.stdout).toContain("1 fix applied");
         expect(readFileSync(runFilePath, "utf-8")).not.toContain("<Nat>");
     });
+    test("read-only file is skipped, not crashed", async () => {
+        const runFilePath = copyFixture("M0223.mo");
+        const before = readFileSync(runFilePath, "utf-8");
+        chmodSync(runFilePath, 0o444);
+        const result = await cli(["check", runFilePath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(result.exitCode).toBe(0);
+        expect(result.stderr).toMatch(/Skipped read-only file/);
+        // File left untouched since the fix couldn't be written.
+        expect(readFileSync(runFilePath, "utf-8")).toBe(before);
+    });
     test("verbose", async () => {
         const result = await cli(["check", "Ok.mo", "--fix", "--verbose"], {
             cwd: fixDir,

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/helpers/autofix-motoko.ts

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
+import chalk from "chalk";
 import { execa } from "execa";
 import { TextDocument } from "vscode-languageserver-textdocument";
 
@@ -186,6 +187,9 @@ export async function autofixMotoko(
   mocArgs: string[],
 ): Promise<AutofixResult | null> {
   const fixedFilesCodes = new Map<string, string[]>();
+  // Frozen migration files are often chmod'd read-only; warn once and skip
+  // them rather than aborting the whole run on EACCES/EPERM.
+  const readOnlySkipped = new Set<string>();
 
   for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
     const fixesByFile = new Map<string, DiagnosticFix[]>();
@@ -212,6 +216,10 @@ export async function autofixMotoko(
     let progress = false;
 
     for (const [file, fixes] of fixesByFile) {
+      if (readOnlySkipped.has(file)) {
+        continue;
+      }
+
       const original = await readFile(file, "utf-8");
       const { text: result, appliedCodes } = applyDiagnosticFixes(
         original,
@@ -222,7 +230,20 @@ export async function autofixMotoko(
         continue;
       }
 
-      await writeFile(file, result, "utf-8");
+      try {
+        await writeFile(file, result, "utf-8");
+      } catch (err: any) {
+        if (err?.code === "EACCES" || err?.code === "EPERM") {
+          readOnlySkipped.add(file);
+          console.warn(
+            chalk.yellow(
+              `Skipped read-only file ${relative(process.cwd(), file)} (${appliedCodes.length} fix(es) not applied)`,
+            ),
+          );
+          continue;
+        }
+        throw err;
+      }
       progress = true;
 
       const existing = fixedFilesCodes.get(file) ?? [];

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/helpers/pocket-ic-client.ts

@@ -1,9 +1,9 @@
 import semver from "semver";
-import { PocketIc, PocketIcServer } from "pic-ic";
-import {
+import type { PocketIc, PocketIcServer } from "pic-ic";
+import type {
   PocketIc as PocketIcModern,
   PocketIcServer as PocketIcServerModern,
-  type StartServerOptions,
+  StartServerOptions,
 } from "pic-js-mops";
 import { readConfig } from "../mops.js";
 
@@ -20,13 +20,19 @@ function isLegacy(): boolean {
 export async function startPocketIc(
   options: StartServerOptions,
 ): Promise<{ server: AnyPocketIcServer; client: AnyPocketIc }> {
+  // Imported lazily so commands that never start a replica don't load the
+  // PocketIC client. `pic-js-mops` ships ESM without `type: module`, which a
+  // static import fails to resolve under tsx (local dev); a dynamic import
+  // resolves it on every platform.
   if (isLegacy()) {
+    const { PocketIc, PocketIcServer } = await import("pic-ic");
     let server = await PocketIcServer.start(options);
     let client = await PocketIc.create(server.getUrl());
     return { server, client };
   }
 
-  let server = await PocketIcServerModern.start(options);
-  let client = await PocketIcModern.create(server.getUrl());
+  const { PocketIc, PocketIcServer } = await import("pic-js-mops");
+  let server = await PocketIcServer.start(options);
+  let client = await PocketIc.create(server.getUrl());
   return { server, client };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.15.0",
+  "version": "2.15.2",
   "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-fix.test.ts

@@ -1,5 +1,11 @@
 import { beforeAll, describe, expect, test } from "@jest/globals";
-import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import {
+  chmodSync,
+  cpSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+} from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "path";
 import { lock } from "proper-lockfile";
@@ -22,7 +28,9 @@ describe("check --fix", () => {
 
   beforeAll(() => {
     for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
-      unlinkSync(path.join(runDir, file));
+      const p = path.join(runDir, file);
+      chmodSync(p, 0o644);
+      unlinkSync(p);
     }
   });
 
@@ -132,6 +140,22 @@ describe("check --fix", () => {
     expect(readFileSync(runFilePath, "utf-8")).not.toContain("<Nat>");
   });
 
+  test("read-only file is skipped, not crashed", async () => {
+    const runFilePath = copyFixture("M0223.mo");
+    const before = readFileSync(runFilePath, "utf-8");
+    chmodSync(runFilePath, 0o444);
+
+    const result = await cli(
+      ["check", runFilePath, "--fix", "--", warningFlags],
+      { cwd: fixDir },
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stderr).toMatch(/Skipped read-only file/);
+    // File left untouched since the fix couldn't be written.
+    expect(readFileSync(runFilePath, "utf-8")).toBe(before);
+  });
+
   test("verbose", async () => {
     const result = await cli(["check", "Ok.mo", "--fix", "--verbose"], {
       cwd: fixDir,

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 };
+  };
+};

package/tests/check-stable/check-limit-warning/migrations/20250301_000000_AddD.mo

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

package/tests/check-stable/check-limit-warning/mops.toml

@@ -0,0 +1,15 @@
+[toolchain]
+moc = "1.5.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "src/main.mo"
+
+[canisters.backend.migrations]
+chain = "migrations"
+check-limit = 1
+
+[canisters.backend.check-stable]
+path = "deployed.most"

package/tests/check-stable/check-limit-warning/src/main.mo

@@ -0,0 +1,12 @@
+import Prim "mo:prim";
+
+actor {
+  let a : Nat;
+  let b : Text;
+  let c : Bool;
+  let d : Int;
+
+  public func check() : async () {
+    Prim.debugPrint(debug_show { a; b; c; d });
+  };
+};

package/tests/check-stable.test.ts

@@ -106,4 +106,28 @@ 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/tests/check.test.ts

@@ -195,4 +195,13 @@ 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/tests/lint-extra-example-rules/lint/migration-self-contained/migration-self-contained.toml

@@ -0,0 +1,7 @@
+name = "migration-self-contained"
+description = "Migration files must not import local modules (relative paths). Got: @path"
+includes = ["**/migrations/**"]
+query = '''
+(import (text_literal) @path @error
+  (#match? @path "^\"[^:]*\"$"))
+'''