ic-mops 2.13.2 → 2.14.1

package/dist/commands/install/install-mops-dep.js

@@ -4,12 +4,11 @@ import path from "node:path";
 import { Buffer } from "node:buffer";
 import { createLogUpdate } from "log-update";
 import chalk from "chalk";
-import { deleteSync } from "del";
 import { checkConfigFile, progressBar, readConfig } from "../../mops.js";
 import { getHighestVersion } from "../../api/getHighestVersion.js";
 import { storageActor } from "../../api/actors.js";
 import { parallel } from "../../parallel.js";
-import { getDepCacheDir, getMopsDepCacheName, isDepCached, } from "../../cache.js";
+import { commitStagingDir, createStagingDir, getDepCacheDir, getMopsDepCacheName, isDepCached, sweepStaleStagingDirs, } from "../../cache.js";
 import { downloadFile, getPackageFilesInfo, } from "../../api/downloadPackageFiles.js";
 import { installDeps } from "./install-deps.js";
 import { getDepName } from "../../helpers/get-dep-name.js";
@@ -37,6 +36,7 @@ export async function installMopsDep(pkg, version = "", { verbose, silent, dep,
         }
         version = versionRes.ok;
     }
+    sweepStaleStagingDirs();
     let cacheName = getMopsDepCacheName(depName, version);
     let cacheDir = getDepCacheDir(cacheName);
     // global cache hit
@@ -60,24 +60,27 @@ export async function installMopsDep(pkg, version = "", { verbose, silent, dep,
                 filesData.set(path, data);
                 progress();
             });
+            let stagingDir = createStagingDir(cacheDir);
             let onSigInt = () => {
-                deleteSync([cacheDir], { force: true });
-                process.exit();
+                fs.rmSync(stagingDir, { recursive: true, force: true });
+                process.exit(130);
             };
             process.on("SIGINT", onSigInt);
-            // write files to global cache
             try {
                 await Promise.all(Array.from(filesData.entries()).map(async ([filePath, data]) => {
-                    await fs.promises.mkdir(path.join(cacheDir, path.dirname(filePath)), { recursive: true });
-                    await fs.promises.writeFile(path.join(cacheDir, filePath), Buffer.from(data));
+                    await fs.promises.mkdir(path.join(stagingDir, path.dirname(filePath)), { recursive: true });
+                    await fs.promises.writeFile(path.join(stagingDir, filePath), Buffer.from(data));
                 }));
+                commitStagingDir(stagingDir, cacheDir);
             }
             catch (err) {
                 console.error(chalk.red("Error: ") + err);
-                deleteSync([cacheDir], { force: true });
+                fs.rmSync(stagingDir, { recursive: true, force: true });
                 return false;
             }
-            process.off("SIGINT", onSigInt);
+            finally {
+                process.off("SIGINT", onSigInt);
+            }
         }
         catch (err) {
             console.error(chalk.red("Error: ") + err);

package/dist/commands/install/sync-local-cache.js

@@ -1,9 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { copyCache, getDepCacheName } from "../../cache.js";
+import { copyCache, getDepCacheName, sweepStaleStagingDirs, } from "../../cache.js";
 import { getDependencyType, getRootDir } from "../../mops.js";
 import { resolvePackages } from "../../resolve-packages.js";
 export async function syncLocalCache({ verbose = false } = {}) {
+    sweepStaleStagingDirs();
     let resolvedPackages = await resolvePackages();
     let rootDir = getRootDir();
     verbose && console.log("Syncing local cache...");

package/dist/commands/lint.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { cliError } from "../error.js";
 import { formatDir, formatGithubDir, getDependencyType, getRootDir, readConfig, } from "../mops.js";
 import { resolvePackages } from "../resolve-packages.js";
+import { withFixLock } from "../helpers/fix-lock.js";
 import { toolchain } from "./toolchain/index.js";
 import { MOTOKO_GLOB_CONFIG } from "../constants.js";
 import { existsSync } from "node:fs";
@@ -109,6 +110,12 @@ async function runLintoko(lintokoBinPath, rootDir, args, options, label) {
     }
 }
 export async function lint(filter, options) {
+    if (options.fix) {
+        return withFixLock(() => lintImpl(filter, options));
+    }
+    return lintImpl(filter, options);
+}
+async function lintImpl(filter, options) {
     let config = readConfig();
     let rootDir = getRootDir();
     let lintokoBinPath = config.toolchain?.lintoko

package/dist/commands/outdated.d.ts

@@ -1,3 +1,4 @@
-export declare function outdated({ major }?: {
+export declare function outdated({ major, patch, }?: {
     major?: boolean;
+    patch?: boolean;
 }): Promise<void>;

package/dist/commands/outdated.js

@@ -2,12 +2,12 @@ import chalk from "chalk";
 import { checkConfigFile, readConfig } from "../mops.js";
 import { getAvailableUpdates } from "./available-updates.js";
 import { getDepName, getDepPinnedVersion } from "../helpers/get-dep-name.js";
-export async function outdated({ major } = {}) {
+export async function outdated({ major, patch, } = {}) {
     if (!checkConfigFile()) {
         return;
     }
     let config = readConfig();
-    let available = await getAvailableUpdates(config, undefined, major ? "major" : "caret");
+    let available = await getAvailableUpdates(config, undefined, major ? "major" : patch ? "patch" : "caret");
     if (available.length === 0) {
         console.log(chalk.green("All dependencies are up to date!"));
     }

package/dist/commands/publish.js

@@ -256,7 +256,6 @@ export async function publish(options = {}) {
         console.log("Running benchmarks...");
         try {
             benchmarks = await bench("", {
-                replica: config.toolchain?.["pocket-ic"] ? "pocket-ic" : "dfx",
                 gc: "copying",
                 forceGc: true,
                 silent: true,

package/dist/commands/test/test.d.ts

@@ -10,5 +10,5 @@ type TestOptions = {
     verbose: boolean;
 };
 export declare function test(filter?: string, options?: Partial<TestOptions>): Promise<void>;
-export declare function testWithReporter(reporterName: ReporterName | Reporter | undefined, filter: string | undefined, defaultMode: TestMode | undefined, replicaType: ReplicaName, watch?: boolean, signal?: AbortSignal): Promise<boolean>;
+export declare function testWithReporter(reporterName: ReporterName | Reporter | undefined, filter: string | undefined, defaultMode: TestMode | undefined, replicaType: ReplicaName, watch?: boolean, signal?: AbortSignal, explicitReplica?: boolean): Promise<boolean>;
 export {};

package/dist/commands/test/test.js

@@ -21,6 +21,7 @@ import { SilentReporter } from "./reporters/silent-reporter.js";
 import { toolchain } from "../toolchain/index.js";
 import { Replica } from "../replica.js";
 import { getDfxVersion } from "../../helpers/get-dfx-version.js";
+import { warnIfDfxReplica } from "../../helpers/deprecate-dfx-replica.js";
 import { MOTOKO_GLOB_CONFIG, MOTOKO_IGNORE_PATTERNS } from "../../constants.js";
 let replica = new Replica();
 let replicaStartPromise;
@@ -47,6 +48,7 @@ export async function test(filter = "", options = {}) {
             replicaType = "dfx-pocket-ic";
         }
     }
+    let explicitReplica = options.replica === "dfx";
     replica.type = replicaType;
     replica.verbose = !!options.verbose;
     if (options.watch) {
@@ -78,7 +80,7 @@ export async function test(filter = "", options = {}) {
             console.clear();
             process.stdout.write("\x1Bc");
             controller = new AbortController();
-            curRun = runAll(options.reporter, filter, options.mode, replicaType, true, controller.signal);
+            curRun = runAll(options.reporter, filter, options.mode, replicaType, true, controller.signal, explicitReplica);
             await curRun;
             console.log("-".repeat(50));
             console.log("Waiting for file changes...");
@@ -94,7 +96,7 @@ export async function test(filter = "", options = {}) {
         run();
     }
     else {
-        let passed = await runAll(options.reporter, filter, options.mode, replicaType);
+        let passed = await runAll(options.reporter, filter, options.mode, replicaType, false, undefined, explicitReplica);
         if (!passed) {
             process.exit(1);
         }
@@ -102,11 +104,11 @@ export async function test(filter = "", options = {}) {
 }
 let mocPath = "";
 let wasmtimePath = "";
-async function runAll(reporterName, filter = "", mode = "interpreter", replicaType, watch = false, signal) {
-    let done = await testWithReporter(reporterName, filter, mode, replicaType, watch, signal);
+async function runAll(reporterName, filter = "", mode = "interpreter", replicaType, watch = false, signal, explicitReplica = false) {
+    let done = await testWithReporter(reporterName, filter, mode, replicaType, watch, signal, explicitReplica);
     return done;
 }
-export async function testWithReporter(reporterName, filter = "", defaultMode = "interpreter", replicaType, watch = false, signal) {
+export async function testWithReporter(reporterName, filter = "", defaultMode = "interpreter", replicaType, watch = false, signal, explicitReplica = false) {
     let rootDir = getRootDir();
     let files = [];
     let libFiles = globSync("**/test?(s)/lib.mo", MOTOKO_GLOB_CONFIG);
@@ -174,6 +176,9 @@ export async function testWithReporter(reporterName, filter = "", defaultMode =
     });
     let hasWasiTests = filesWithMode.some(({ mode }) => mode === "wasi");
     let hasReplicaTests = filesWithMode.some(({ mode }) => mode === "replica");
+    if (hasReplicaTests) {
+        warnIfDfxReplica(replicaType, explicitReplica);
+    }
     // prepare wasmtime path
     if (hasWasiTests && !wasmtimePath) {
         // ensure wasmtime is installed or specified in config

package/dist/commands/update.d.ts

@@ -3,6 +3,7 @@ type UpdateOptions = {
     dev?: boolean;
     lock?: "update" | "ignore";
     major?: boolean;
+    patch?: boolean;
 };
-export declare function update(pkg?: string, { lock, major }?: UpdateOptions): Promise<void>;
+export declare function update(pkg?: string, { lock, major, patch }?: UpdateOptions): Promise<void>;
 export {};

package/dist/commands/update.js

@@ -4,7 +4,7 @@ import { add } from "./add.js";
 import { getAvailableUpdates } from "./available-updates.js";
 import { checkIntegrity } from "../integrity.js";
 import { getDepName, getDepPinnedVersion } from "../helpers/get-dep-name.js";
-export async function update(pkg, { lock, major } = {}) {
+export async function update(pkg, { lock, major, patch } = {}) {
     if (!checkConfigFile()) {
         return;
     }
@@ -36,7 +36,7 @@ export async function update(pkg, { lock, major } = {}) {
         }
     }
     // update mops packages
-    let available = await getAvailableUpdates(config, pkg, major ? "major" : "caret");
+    let available = await getAvailableUpdates(config, pkg, major ? "major" : patch ? "patch" : "caret");
     if (available.length === 0) {
         if (pkg) {
             console.log(chalk.green(`Package "${pkg}" is up to date!`));

package/dist/commands/watch/tester.js

@@ -36,7 +36,10 @@ export class Tester {
         this.reporter = new SilentReporter(false, onProgress);
         this.controller = new AbortController();
         let config = readConfig();
-        this.currentRun = testWithReporter(this.reporter, "", "interpreter", config.toolchain?.["pocket-ic"] ? "pocket-ic" : "dfx", true, this.controller.signal);
+        let replicaType = config.toolchain?.["pocket-ic"]
+            ? "pocket-ic"
+            : "dfx";
+        this.currentRun = testWithReporter(this.reporter, "", "interpreter", replicaType, true, this.controller.signal);
         await this.currentRun;
         if (!this.aborted) {
             this.status = this.reporter.failed > 0 ? "error" : "success";

package/dist/helpers/autofix-motoko.d.ts

@@ -16,7 +16,7 @@ export interface MocDiagnostic {
     spans: MocSpan[];
     notes: string[];
 }
-export declare function parseDiagnostics(stdout: string): MocDiagnostic[];
+export declare function parseDiagnostics(stdout: string | undefined): MocDiagnostic[];
 export interface AutofixResult {
     /** Map of file path → diagnostic codes fixed in that file */
     fixedFiles: Map<string, string[]>;

package/dist/helpers/autofix-motoko.js

@@ -3,6 +3,9 @@ import { resolve } from "node:path";
 import { execa } from "execa";
 import { TextDocument, } from "vscode-languageserver-textdocument";
 export function parseDiagnostics(stdout) {
+    if (!stdout) {
+        return [];
+    }
     return stdout
         .split("\n")
         .filter((l) => l.trim())
@@ -106,14 +109,13 @@ export async function autofixMotoko(mocPath, files, mocArgs) {
     const fixedFilesCodes = new Map();
     for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
         const fixesByFile = new Map();
-        for (const file of files) {
-            const result = await execa(mocPath, [file, ...mocArgs, "--error-format=json"], { stdio: "pipe", reject: false });
-            const diagnostics = parseDiagnostics(result.stdout);
-            for (const [targetFile, fixes] of extractDiagnosticFixes(diagnostics)) {
-                const existing = fixesByFile.get(targetFile) ?? [];
-                existing.push(...fixes);
-                fixesByFile.set(targetFile, existing);
-            }
+        // Single invocation: moc dedups shared imports across all files.
+        const result = await execa(mocPath, [...files, ...mocArgs, "--error-format=json"], { stdio: "pipe", reject: false });
+        const diagnostics = parseDiagnostics(result.stdout);
+        for (const [targetFile, fixes] of extractDiagnosticFixes(diagnostics)) {
+            const existing = fixesByFile.get(targetFile) ?? [];
+            existing.push(...fixes);
+            fixesByFile.set(targetFile, existing);
         }
         if (fixesByFile.size === 0) {
             break;

package/dist/helpers/deprecate-dfx-replica.d.ts

@@ -0,0 +1,2 @@
+export type ReplicaName = "dfx" | "pocket-ic" | "dfx-pocket-ic";
+export declare function warnIfDfxReplica(replicaType: ReplicaName, explicit: boolean): void;

package/dist/helpers/deprecate-dfx-replica.js

@@ -0,0 +1,20 @@
+import chalk from "chalk";
+let alreadyWarned = false;
+// Prints a deprecation warning (once per process) when `mops bench`/`mops test`/
+// `mops watch` is about to use a dfx-backed replica. Removal is tracked in
+// NEXT-MAJOR.md under "Drop dfx coupling".
+export function warnIfDfxReplica(replicaType, explicit) {
+    if (alreadyWarned) {
+        return;
+    }
+    if (replicaType !== "dfx" && replicaType !== "dfx-pocket-ic") {
+        return;
+    }
+    alreadyWarned = true;
+    let lead = explicit && replicaType === "dfx"
+        ? "`--replica dfx` is deprecated and will be removed in a future release."
+        : replicaType === "dfx-pocket-ic"
+            ? "Falling back to dfx-bundled PocketIC because no `pocket-ic` version is set in `[toolchain]`. This fallback is deprecated and will be removed in a future release."
+            : "Using `dfx` replica because no `pocket-ic` version is set in `[toolchain]`. The `dfx` replica is deprecated and will be removed in a future release.";
+    console.log(chalk.yellow(`${lead}\nRun \`mops toolchain use pocket-ic 12.0.0\` to pin a PocketIC version and silence this warning.`));
+}

package/dist/helpers/fix-lock.d.ts

@@ -0,0 +1 @@
+export declare function withFixLock<T>(fn: () => Promise<T>): Promise<T>;

package/dist/helpers/fix-lock.js

@@ -0,0 +1,93 @@
+import chalk from "chalk";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { lock, unlockSync } from "proper-lockfile";
+import { getRootDir } from "../mops.js";
+// Serializes Motoko-source-writing commands (`check --fix`, `lint --fix`)
+// across concurrent `mops` invocations in the same project. Two parallel
+// `--fix` runs can otherwise apply stale moc byte offsets to a sibling's
+// already-mutated file, corrupting source. Cargo-style: print a wait
+// message after the first failed acquire, then retry with backoff.
+//
+// Re-entrant within a single process so `mops check --fix` (which calls
+// `mops lint --fix` internally) doesn't deadlock against itself.
+let depth = 0;
+let acquiring = false;
+export async function withFixLock(fn) {
+    if (depth > 0) {
+        depth++;
+        try {
+            return await fn();
+        }
+        finally {
+            depth--;
+        }
+    }
+    // Sequential re-entry is handled by `depth`; concurrent top-level calls
+    // (`Promise.all([withFixLock(a), withFixLock(b)])`) would otherwise
+    // serialize awkwardly via proper-lockfile's ELOCKED retry path — with a
+    // confusing intra-process "Waiting..." log line. Fail loudly instead so
+    // the next caller finds out at the call site. Must be set synchronously
+    // before any await, so concurrent entries can't both pass the check.
+    if (acquiring) {
+        throw new Error("withFixLock cannot be called concurrently within the same process");
+    }
+    acquiring = true;
+    try {
+        const rootDir = getRootDir();
+        if (!rootDir) {
+            return await fn();
+        }
+        const lockDir = join(rootDir, ".mops");
+        await mkdir(lockDir, { recursive: true });
+        const lockTarget = join(lockDir, "fix.lock");
+        await writeFile(lockTarget, "", { flag: "a" });
+        const stale = 300_000;
+        let release;
+        try {
+            release = await lock(lockTarget, { stale, retries: 0 });
+        }
+        catch (err) {
+            if (err?.code !== "ELOCKED") {
+                throw err;
+            }
+            console.log(chalk.gray("Waiting for another `mops --fix` run to finish..."));
+            try {
+                release = await lock(lockTarget, {
+                    stale,
+                    retries: { retries: 240, minTimeout: 250, maxTimeout: 2_000 },
+                });
+            }
+            catch (err2) {
+                // proper-lockfile creates `<lockTarget>.lock/` (a directory) for the actual lock,
+                // so manual recovery means removing that, not the empty marker file.
+                throw new Error(`Failed to acquire mops fix lock at ${lockTarget} — another --fix process may be stuck. Remove the ${lockTarget}.lock directory to recover.${err2?.message ? `\n${err2.message}` : ""}`);
+            }
+        }
+        // proper-lockfile registers its own signal-exit handler, but it doesn't reliably
+        // fire on process.exit(). This manual handler covers that gap. Double-unlock is
+        // harmless (the second call throws and is caught).
+        const exitCleanup = () => {
+            try {
+                unlockSync(lockTarget);
+            }
+            catch { }
+        };
+        process.on("exit", exitCleanup);
+        depth = 1;
+        try {
+            return await fn();
+        }
+        finally {
+            depth = 0;
+            process.removeListener("exit", exitCleanup);
+            try {
+                await release();
+            }
+            catch { }
+        }
+    }
+    finally {
+        acquiring = false;
+    }
+}

package/dist/integrity.d.ts

@@ -22,6 +22,6 @@ export declare function readLockFile(): LockFile | null;
 export declare function checkLockFileLight(): boolean;
 export declare function updateLockFile({ force, }?: {
     force?: boolean;
-}): Promise<void>;
-export declare function checkLockFile(force?: boolean): Promise<void>;
+}): Promise<boolean>;
+export declare function checkLockFile(force?: boolean, regenerated?: boolean): Promise<void>;
 export {};

package/dist/integrity.js

@@ -13,8 +13,8 @@ export async function checkIntegrity(lock) {
         lock = process.env["CI"] ? "check" : "update";
     }
     if (lock === "update") {
-        await updateLockFile({ force });
-        await checkLockFile(force);
+        let regenerated = await updateLockFile({ force });
+        await checkLockFile(force, regenerated);
     }
     else if (lock === "check") {
         await checkLockFile(force);
@@ -108,12 +108,14 @@ export function checkLockFileLight() {
     }
     return false;
 }
+// returns true if the lock file was (re)written, false if it was skipped
+// because the existing lock is still valid.
 export async function updateLockFile({ force = false, } = {}) {
     // if lock file exists and mops.toml hasn't changed, don't update it
     // (unless forced: `--lock update` must unconditionally regenerate so users
     // can recover from a corrupt lockfile without `rm mops.lock`)
     if (!force && checkLockFileLight()) {
-        return;
+        return false;
     }
     let resolvedDeps = await resolvePackages();
     let fileHashes = await getFileHashesFromRegistry();
@@ -138,9 +140,12 @@ export async function updateLockFile({ force = false, } = {}) {
         console.log("  Applications: commit this file.");
         console.log("  Libraries: add mops.lock to .gitignore.");
     }
+    return true;
 }
 // compare hashes of local files with hashes from the lock file
-export async function checkLockFile(force = false) {
+// `regenerated` indicates the lockfile was just rewritten from the registry
+// (via `updateLockFile`), so any remaining hash mismatch must be a local edit.
+export async function checkLockFile(force = false, regenerated = false) {
     let supportedVersions = [1, 2, 3];
     let rootDir = getRootDir();
     let lockFile = path.join(rootDir, "mops.lock");
@@ -231,8 +236,19 @@ export async function checkLockFile(force = false) {
                 console.error(`Locked hash: ${lockedHash}`);
                 console.error(`Actual hash: ${localHash}`);
                 console.error("");
-                console.error("If you have not modified files under .mops/, your lockfile may be stale or corrupt.");
-                console.error("Run `mops install --lock update` to regenerate it.");
+                if (regenerated) {
+                    // The lock was just rewritten from the registry, so the only way
+                    // for a per-file hash to still differ is that .mops/<file> was
+                    // edited locally. Point users at the actual fix.
+                    let pkgDir = fileId.split("/")[0];
+                    console.error(`.mops/${fileId} differs from the registry — your local copy has been modified.`);
+                    console.error(`To restore from the global cache, delete the \`.mops/${pkgDir}\` directory and run \`mops install\`.`);
+                    console.error("To keep custom changes, use a `repo` or `path` entry in mops.toml instead of editing .mops/ directly.");
+                }
+                else {
+                    console.error("If you have not modified files under .mops/, your lockfile may be stale or corrupt.");
+                    console.error("Run `mops install --lock update` to regenerate it.");
+                }
                 process.exit(1);
             }
         }

package/dist/mops.js

@@ -1,7 +1,7 @@
 import process from "node:process";
 import path from "node:path";
 import fs from "node:fs";
-import TOML from "@iarna/toml";
+import TOML from "smol-toml";
 import chalk from "chalk";
 import prompts from "prompts";
 import { decodeFile } from "./pem.js";

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.13.2",
+  "version": "2.14.1",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",
@@ -29,7 +29,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@iarna/toml": "2.2.5",
+    "smol-toml": "1.6.1",
     "@icp-sdk/core": "4.0.2",
     "@noble/hashes": "1.8.0",
     "as-table": "1.0.55",
@@ -93,6 +93,6 @@
     "ts-jest": "29.4.5",
     "tsx": "4.19.2",
     "typescript": "5.9.2",
-    "wasm-pack": "0.13.1"
+    "wasm-pack": "0.15.0"
   }
 }

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

@@ -1,6 +1,8 @@
 import { beforeAll, describe, expect, test } from "@jest/globals";
 import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
 import path from "path";
+import { lock } from "proper-lockfile";
 import { parseDiagnostics } from "../helpers/autofix-motoko";
 import { cli, normalizePaths } from "./helpers";
 function countCodes(stdout) {
@@ -36,6 +38,12 @@ describe("check --fix", () => {
         expect(countCodes(afterResult.stdout)).toEqual(expectedAfterDiagnostics);
         return runFilePath;
     }
+    test("parseDiagnostics tolerates missing moc output", () => {
+        // execa with reject:false yields undefined stdout when moc fails to spawn
+        // or is killed (e.g. OOM); parsing must degrade to no diagnostics, not throw.
+        expect(parseDiagnostics(undefined)).toEqual([]);
+        expect(parseDiagnostics("")).toEqual([]);
+    });
     test("M0223", async () => {
         await testCheckFix("M0223.mo", { M0223: 1 });
     });
@@ -103,4 +111,36 @@ describe("check --fix", () => {
         expect(result.stderr).toMatch(/error/i);
         expect(result.stdout).not.toMatch(/✓ run/);
     });
+    test("concurrent --fix runs serialize and produce the same output", async () => {
+        const runFilePath = copyFixture("edit-suggestions.mo");
+        await cli(["check", runFilePath, "--fix", "--", warningFlags], {
+            cwd: fixDir,
+        });
+        const expected = readFileSync(runFilePath, "utf-8");
+        copyFixture("edit-suggestions.mo");
+        // Hold the lock from the test process itself so both children
+        // deterministically hit ELOCKED, print "Waiting...", and queue.
+        const lockTarget = path.join(fixDir, ".mops", "fix.lock");
+        await mkdir(path.dirname(lockTarget), { recursive: true });
+        await writeFile(lockTarget, "", { flag: "a" });
+        const release = await lock(lockTarget, { stale: 30_000 });
+        const childA = cli(["check", runFilePath, "--fix", "--", warningFlags], {
+            cwd: fixDir,
+        });
+        const childB = cli(["check", runFilePath, "--fix", "--", warningFlags], {
+            cwd: fixDir,
+        });
+        // Hold long enough for both children to spawn (`npm run mops` → bundler →
+        // CLI startup) and attempt the non-blocking acquire. 5s is conservative —
+        // local runs land well under 2s, the headroom is purely to absorb CI jitter.
+        await new Promise((r) => setTimeout(r, 5000));
+        await release();
+        const [a, b] = await Promise.all([childA, childB]);
+        expect(a.exitCode).toBe(0);
+        expect(b.exitCode).toBe(0);
+        expect(readFileSync(runFilePath, "utf-8")).toBe(expected);
+        // At least one child must have hit the held lock and queued; if neither
+        // did, the lock didn't actually serialize anything.
+        expect(a.stdout + b.stdout).toContain("Waiting for another");
+    });
 });

package/dist/tests/check.test.js

@@ -12,6 +12,12 @@ describe("check", () => {
         await cliSnapshot(["check", "Error.mo"], { cwd }, 1);
         await cliSnapshot(["check", "Ok.mo", "Error.mo"], { cwd }, 1);
     });
+    // The verbose snapshot shows a single "moc ... [both files]" line, proving the
+    // whole set is checked in one invocation rather than one moc call per file.
+    test("multiple files in a single invocation", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        await cliSnapshot(["check", "Ok.mo", "Warning.mo", "--verbose"], { cwd }, 0);
+    });
     test("warning", async () => {
         const cwd = path.join(import.meta.dirname, "check/success");
         const result = await cliSnapshot(["check", "Warning.mo"], { cwd }, 0);