ic-mops 2.15.2 → 2.16.1

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Next
 
+## 2.16.1
+
+- Fix `mops bench` crashing on moc 0.15+ with the default `--gc copying`: `--copying-gc` is rejected under enhanced orthogonal persistence, which became the default persistence mode in 2.16.0. The default GC is now `incremental` (moc's default and the only collector available under EOP). Selecting a legacy collector (`copying`, `compacting`, `generational`) now implies `--legacy-persistence`, since moc only accepts them there.
+- `mops build`, `mops check`, `mops generate`, and `mops check-stable` now tunnel `moc`'s exit code instead of always exiting `1`. moc exits `2` on a compiler crash (uncaught internal error) versus `1` for normal user errors (type/compile errors, stable-compat mismatch, bad args), so CI and scripts can now distinguish "file a Motoko bug" from "fix your code" via `$?`. `mops test` likewise exits `2` when a `moc` process crashes during a test run, instead of reporting it as an ordinary test failure.
+
+## 2.16.0
+
+- `mops bench` now compiles benchmark canisters under **enhanced orthogonal persistence** (moc's default) instead of forcing `--legacy-persistence` — measuring the persistence mode real canisters run. Pass `--legacy-persistence` to opt back into legacy persistence.
+- `mops bench --query` measures each cell in a **query** call instead of an update call. Queries run no GC on the IC, so the instruction counts exclude GC work an update would incur — for benchmarking `query`/read-only workloads realistically. Only for synchronous benchmark runners (no inter-canister `await`).
+- `[requirements].lintoko` declares a minimum lintoko version for package consumers. `mops install` (and `mops add`, `mops toolchain use`) warn when the project's lintoko is below a dependency's requirement, same as `moc` (#597).
+
 ## 2.15.2
 
 - `mops check-stable` (and the stable check inside `mops check`) reports when `[canisters.<name>.migrations].check-limit` is set but more migrations are pending than the limit allows. If the compatibility check failed, the check-limit diagnostic replaces the misleading `moc` error; if it passed anyway, a warning is shown. Compares the deployed `.most` baseline against the local chain; use `--no-check-limit` to suppress.

package/check-requirements.ts

@@ -5,47 +5,69 @@ import chalk from "chalk";
 import { getDependencyType, getRootDir, readConfig } from "./mops.js";
 import { resolvePackages } from "./resolve-packages.js";
 import { getMocSemVer } from "./helpers/get-moc-version.js";
+import { getLintokoSemVer } from "./helpers/get-lintoko-version.js";
 import { getPackageId } from "./helpers/get-package-id.js";
+import type { Requirements } from "./types.js";
+
+type ToolRequirement = keyof Requirements;
+
+const TOOL_REQUIREMENTS: {
+  tool: ToolRequirement;
+  getInstalled: () => SemVer | null;
+}[] = [
+  { tool: "moc", getInstalled: getMocSemVer },
+  { tool: "lintoko", getInstalled: getLintokoSemVer },
+];
 
 export async function checkRequirements({ verbose = false } = {}) {
-  let installedMoc = getMocSemVer();
-  if (!installedMoc) {
-    return;
-  }
-  let highestRequiredMoc = new SemVer("0.0.0");
-  let highestRequiredMocPkgId = "";
   let rootDir = getRootDir();
-
   let resolvedPackages = await resolvePackages();
-  for (let [name, version] of Object.entries(resolvedPackages)) {
-    if (getDependencyType(version) === "mops") {
-      let pkgId = getPackageId(name, version);
-      let depConfig = readConfig(
-        path.join(rootDir, ".mops", pkgId, "mops.toml"),
-      );
-      let moc = depConfig.requirements?.moc;
-
-      if (moc) {
-        let requiredMoc = new SemVer(moc);
-        if (highestRequiredMoc.compare(requiredMoc) < 0) {
-          highestRequiredMoc = requiredMoc;
-          highestRequiredMocPkgId = pkgId;
+
+  for (let { tool, getInstalled } of TOOL_REQUIREMENTS) {
+    let installed = getInstalled();
+    if (!installed) {
+      continue;
+    }
+
+    let highestRequired = new SemVer("0.0.0");
+    let highestRequiredPkgId = "";
+
+    for (let [name, version] of Object.entries(resolvedPackages)) {
+      if (getDependencyType(version) === "mops") {
+        let pkgId = getPackageId(name, version);
+        let depConfig = readConfig(
+          path.join(rootDir, ".mops", pkgId, "mops.toml"),
+        );
+        let required = depConfig.requirements?.[tool];
+
+        if (required) {
+          let requiredVersion = new SemVer(required);
+          if (highestRequired.compare(requiredVersion) < 0) {
+            highestRequired = requiredVersion;
+            highestRequiredPkgId = pkgId;
+          }
+          verbose && _check(tool, pkgId, installed, requiredVersion);
         }
-        verbose && _check(pkgId, installedMoc, requiredMoc);
       }
     }
-  }
 
-  verbose || _check(highestRequiredMocPkgId, installedMoc, highestRequiredMoc);
+    verbose || _check(tool, highestRequiredPkgId, installed, highestRequired);
+  }
 }
 
-function _check(pkgId: string, installedMoc: SemVer, requiredMoc: SemVer) {
-  let comp = installedMoc.compare(requiredMoc);
-  if (comp < 0) {
-    console.log(
-      chalk.yellow(`moc version does not meet the requirements of ${pkgId}`),
-    );
-    console.log(chalk.yellow(`  Required: >= ${requiredMoc.format()}`));
-    console.log(chalk.yellow(`  Installed:   ${installedMoc.format()}`));
+function _check(
+  tool: ToolRequirement,
+  pkgId: string,
+  installed: SemVer,
+  required: SemVer,
+) {
+  if (!pkgId || installed.compare(required) >= 0) {
+    return;
   }
+
+  console.log(
+    chalk.yellow(`${tool} version does not meet the requirements of ${pkgId}`),
+  );
+  console.log(chalk.yellow(`  Required: >= ${required.format()}`));
+  console.log(chalk.yellow(`  Installed:   ${installed.format()}`));
 }

package/cli.ts

@@ -544,9 +544,12 @@ program
     ).choices(["dfx", "pocket-ic"]),
   )
   .addOption(
-    new Option("--gc <gc>", "Garbage collector")
+    new Option(
+      "--gc <gc>",
+      "Garbage collector. Under enhanced orthogonal persistence (the default) the GC is fixed to `incremental`; selecting `copying`, `compacting`, or `generational` implies `--legacy-persistence`",
+    )
       .choices(["copying", "compacting", "generational", "incremental"])
-      .default("copying"),
+      .default("incremental"),
   )
   .addOption(
     new Option("--save", "Save benchmark results to .bench/<filename>.json"),
@@ -558,10 +561,22 @@ program
     ),
   )
   // .addOption(new Option('--force-gc', 'Force GC'))
+  .addOption(
+    new Option(
+      "--query",
+      "Measure each cell in a query call (how `query` methods run on the IC: no GC). Only for benchmarks whose runner is synchronous (no inter-canister calls)",
+    ),
+  )
+  .addOption(
+    new Option(
+      "--legacy-persistence",
+      "Compile benchmark canisters under legacy persistence instead of enhanced orthogonal persistence (the default)",
+    ),
+  )
   .addOption(
     new Option(
       "--verbose",
-      "Print the benchmark pipeline (compiler, replica, GC, optimization) and stream compiler/replica output, including dfx optimization warnings",
+      "Print the benchmark pipeline (compiler, replica, GC, context, persistence, profile, optimization) and stream compiler/replica output, including dfx optimization warnings",
     ),
   )
   .action(async (filter, options) => {

package/commands/bench.ts

@@ -40,6 +40,8 @@ type BenchOptions = {
   compilerVersion: string;
   gc: "copying" | "compacting" | "generational" | "incremental";
   forceGc: boolean;
+  query: boolean;
+  legacyPersistence: boolean;
   save: boolean;
   compare: boolean;
   verbose: boolean;
@@ -59,8 +61,10 @@ export async function bench(
     replicaVersion: "",
     compiler: "moc",
     compilerVersion: getMocVersion(true),
-    gc: "copying",
+    gc: "incremental",
     forceGc: true,
+    query: false,
+    legacyPersistence: false,
     save: false,
     compare: false,
     verbose: false,
@@ -108,6 +112,8 @@ export async function bench(
       replicaType === "dfx" || replicaType === "dfx-pocket-ic"
         ? 'dfx `optimize: "cycles"` (ic-wasm) on deploy'
         : "none (raw moc output)";
+    let legacyGc = isLegacyGc(options.gc);
+    let effectiveLegacyPersistence = options.legacyPersistence || legacyGc;
     console.log(chalk.gray("Benchmark pipeline:"));
     console.log(chalk.gray(`  compiler:  moc ${options.compilerVersion}`));
     console.log(
@@ -120,6 +126,21 @@ export async function bench(
         `  gc:        ${options.gc}${options.forceGc ? " (forced)" : ""}`,
       ),
     );
+    console.log(
+      chalk.gray(`  context:   ${options.query ? "query" : "update"}`),
+    );
+    console.log(
+      chalk.gray(
+        `  persistence: ${effectiveLegacyPersistence ? "legacy" : "enhanced"}`,
+      ),
+    );
+    if (legacyGc && !options.legacyPersistence) {
+      console.log(
+        chalk.gray(
+          `  (gc '${options.gc}' only exists under legacy persistence; enabling --legacy-persistence)`,
+        ),
+      );
+    }
     console.log(chalk.gray(`  profile:   ${options.profile}`));
     console.log(chalk.gray(`  optimize:  ${optimize}`));
   }
@@ -267,13 +288,25 @@ function computeDiffAll(
   return diff;
 }
 
+// Collectors that only exist under legacy persistence. moc 0.15+ fixes the GC to
+// incremental under enhanced orthogonal persistence and rejects these there.
+function isLegacyGc(gc: BenchOptions["gc"]): boolean {
+  return gc === "copying" || gc === "compacting" || gc === "generational";
+}
+
 function getMocArgs(options: BenchOptions): string {
   let args = "";
 
-  if (
-    options.compilerVersion &&
-    new SemVer(options.compilerVersion).compare("0.15.0") >= 0
-  ) {
+  let mocAtLeast015 =
+    !!options.compilerVersion &&
+    new SemVer(options.compilerVersion).compare("0.15.0") >= 0;
+
+  // Legacy collectors require legacy persistence; moc < 0.15 is already legacy
+  // and has no --legacy-persistence flag.
+  let useLegacyPersistence =
+    options.legacyPersistence || isLegacyGc(options.gc);
+
+  if (useLegacyPersistence && mocAtLeast015) {
     args += " --legacy-persistence";
   }
 
@@ -281,7 +314,8 @@ function getMocArgs(options: BenchOptions): string {
     args += " --force-gc";
   }
 
-  if (options.gc) {
+  // Under EOP the GC is fixed; only pass a collector flag where it's selectable.
+  if (options.gc && (useLegacyPersistence || !mocAtLeast015)) {
     args += ` --${options.gc}-gc`;
   }
 
@@ -533,13 +567,14 @@ async function runBenchFile(
     log();
   }
 
-  // run all cells
+  // run all cells. `--query` measures in query context (how `query` methods
+  // actually run on the IC: no GC), at the cost of not supporting benches whose
+  // runner performs async calls. Otherwise use the update path.
   for (let [rowIndex, row] of schema.rows.entries()) {
     for (let [colIndex, col] of schema.cols.entries()) {
-      let res = await actor.runCellUpdateAwait(
-        BigInt(rowIndex),
-        BigInt(colIndex),
-      );
+      let res = options.query
+        ? await actor.runCellQuery(BigInt(rowIndex), BigInt(colIndex))
+        : await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
       results.set(`${row}:${col}`, res);
 
       // @ts-ignore

package/commands/build.ts

@@ -4,7 +4,7 @@ import { exists } from "fs-extra";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { lock, unlockSync } from "proper-lockfile";
-import { cliError } from "../error.js";
+import { cliError, cliExit } from "../error.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
 import {
   filterCanisters,
@@ -136,7 +136,8 @@ export async function build(
               console.error(result.stdout);
             }
           }
-          cliError(
+          cliExit(
+            result.exitCode ?? 1,
             `Build failed for canister ${canisterName} (exit code: ${result.exitCode})`,
           );
         }

package/commands/check-stable.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, mkdtempSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import chalk from "chalk";
 import { execa } from "execa";
-import { cliError } from "../error.js";
+import { cliError, cliExit } from "../error.js";
 import {
   getCheckLimitPendingIssue,
   prepareMigrationArgs,
@@ -261,7 +261,8 @@ export async function runStableCheck(
       if (result.stderr) {
         console.error(result.stderr);
       }
-      cliError(
+      cliExit(
+        result.exitCode ?? 1,
         `✗ Stable compatibility check failed for canister '${canisterName}'`,
       );
     }
@@ -314,7 +315,8 @@ async function generateStableTypes(
     if (result.stderr) {
       console.error(result.stderr);
     }
-    cliError(
+    cliExit(
+      result.exitCode ?? 1,
       `Failed to generate stable types for ${moFile} (exit code: ${result.exitCode})`,
     );
   }

package/commands/check.ts

@@ -1,7 +1,7 @@
 import path from "node:path";
 import chalk from "chalk";
 import { execa } from "execa";
-import { cliError } from "../error.js";
+import { cliError, cliExit } from "../error.js";
 import {
   getGlobalMocArgs,
   getRootDir,
@@ -208,7 +208,8 @@ async function checkCanisters(
         });
 
         if (result.exitCode !== 0) {
-          cliError(
+          cliExit(
+            result.exitCode ?? 1,
             `✗ Check failed for canister ${canisterName} (exit code: ${result.exitCode})`,
           );
         }
@@ -285,7 +286,8 @@ async function checkFiles(
       });
 
       if (result.exitCode !== 0) {
-        cliError(
+        cliExit(
+          result.exitCode ?? 1,
           `✗ Check failed for file ${file} (exit code: ${result.exitCode})`,
         );
       }

package/commands/generate.ts

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import { execa } from "execa";
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
-import { cliError } from "../error.js";
+import { cliError, cliExit } from "../error.js";
 import {
   filterCanisters,
   resolveCanisterConfigs,
@@ -104,7 +104,8 @@ export async function generateCandid(
             console.error(result.stdout);
           }
         }
-        cliError(
+        cliExit(
+          result.exitCode ?? 1,
           `Failed to generate Candid for canister ${canisterName} (exit code: ${result.exitCode})`,
         );
       }

package/commands/test/test.ts

@@ -159,7 +159,7 @@ export async function test(filter = "", options: Partial<TestOptions> = {}) {
       explicitReplica,
     );
     if (!passed) {
-      process.exit(1);
+      process.exit(maxMocExit >= 2 ? 2 : 1);
     }
   }
 }
@@ -167,6 +167,13 @@ export async function test(filter = "", options: Partial<TestOptions> = {}) {
 let mocPath = "";
 let wasmtimePath = "";
 
+let maxMocExit = 0;
+const trackMocExit = (code: number | null) => {
+  if (code && code >= 2) {
+    maxMocExit = Math.max(maxMocExit, code);
+  }
+};
+
 async function runAll(
   reporterName: ReporterName | undefined,
   filter = "",
@@ -197,6 +204,7 @@ export async function testWithReporter(
   signal?: AbortSignal,
   explicitReplica = false,
 ): Promise<boolean> {
+  maxMocExit = 0;
   let rootDir = getRootDir();
   let files: string[] = [];
   let libFiles = globSync("**/test?(s)/lib.mo", MOTOKO_GLOB_CONFIG);
@@ -328,7 +336,7 @@ export async function testWithReporter(
           }
           throw error;
         });
-        pipeMMF(proc, mmf).then(resolve);
+        pipeMMF(proc, mmf, trackMocExit).then(resolve);
       }
       // build and run wasm
       else if (mode === "wasi") {
@@ -346,7 +354,7 @@ export async function testWithReporter(
           }
           throw error;
         });
-        pipeMMF(buildProc, mmf)
+        pipeMMF(buildProc, mmf, trackMocExit)
           .then(async () => {
             if (mmf.failed > 0) {
               return;
@@ -413,7 +421,7 @@ export async function testWithReporter(
           throw error;
         });
 
-        pipeMMF(buildProc, mmf)
+        pipeMMF(buildProc, mmf, trackMocExit)
           .then(async () => {
             if (mmf.failed > 0) {
               return;

package/commands/test/utils.ts

@@ -68,18 +68,22 @@ export function pipeStderrToMMF(stderr: Readable, mmf: MMF1, dir = "") {
   });
 }
 
-export function pipeMMF(proc: ChildProcessWithoutNullStreams, mmf: MMF1) {
+export function pipeMMF(
+  proc: ChildProcessWithoutNullStreams,
+  mmf: MMF1,
+  onClose?: (code: number | null) => void,
+) {
   return new Promise<void>((resolve) => {
     pipeStdoutToMMF(proc.stdout, mmf);
     pipeStderrToMMF(proc.stderr, mmf);
 
-    // exit
     proc.on("close", (code) => {
       if (code === 0) {
         mmf.strategy !== "print" && mmf.pass();
       } else if (code !== 1) {
         mmf.fail(`unknown exit code: ${code}`);
       }
+      onClose?.(code ?? null);
       resolve();
     });
   });

package/commands/toolchain/index.ts

@@ -337,9 +337,7 @@ async function update(tool?: Tool) {
     config.toolchain[tool] = version;
     writeConfig(config);
 
-    if (tool === "moc") {
-      await checkRequirements();
-    }
+    await checkRequirements();
 
     if (oldVersion === version) {
       console.log(`Latest ${tool} ${version} is already installed`);

package/dist/check-requirements.js

@@ -4,38 +4,45 @@ import chalk from "chalk";
 import { getDependencyType, getRootDir, readConfig } from "./mops.js";
 import { resolvePackages } from "./resolve-packages.js";
 import { getMocSemVer } from "./helpers/get-moc-version.js";
+import { getLintokoSemVer } from "./helpers/get-lintoko-version.js";
 import { getPackageId } from "./helpers/get-package-id.js";
+const TOOL_REQUIREMENTS = [
+    { tool: "moc", getInstalled: getMocSemVer },
+    { tool: "lintoko", getInstalled: getLintokoSemVer },
+];
 export async function checkRequirements({ verbose = false } = {}) {
-    let installedMoc = getMocSemVer();
-    if (!installedMoc) {
-        return;
-    }
-    let highestRequiredMoc = new SemVer("0.0.0");
-    let highestRequiredMocPkgId = "";
     let rootDir = getRootDir();
     let resolvedPackages = await resolvePackages();
-    for (let [name, version] of Object.entries(resolvedPackages)) {
-        if (getDependencyType(version) === "mops") {
-            let pkgId = getPackageId(name, version);
-            let depConfig = readConfig(path.join(rootDir, ".mops", pkgId, "mops.toml"));
-            let moc = depConfig.requirements?.moc;
-            if (moc) {
-                let requiredMoc = new SemVer(moc);
-                if (highestRequiredMoc.compare(requiredMoc) < 0) {
-                    highestRequiredMoc = requiredMoc;
-                    highestRequiredMocPkgId = pkgId;
+    for (let { tool, getInstalled } of TOOL_REQUIREMENTS) {
+        let installed = getInstalled();
+        if (!installed) {
+            continue;
+        }
+        let highestRequired = new SemVer("0.0.0");
+        let highestRequiredPkgId = "";
+        for (let [name, version] of Object.entries(resolvedPackages)) {
+            if (getDependencyType(version) === "mops") {
+                let pkgId = getPackageId(name, version);
+                let depConfig = readConfig(path.join(rootDir, ".mops", pkgId, "mops.toml"));
+                let required = depConfig.requirements?.[tool];
+                if (required) {
+                    let requiredVersion = new SemVer(required);
+                    if (highestRequired.compare(requiredVersion) < 0) {
+                        highestRequired = requiredVersion;
+                        highestRequiredPkgId = pkgId;
+                    }
+                    verbose && _check(tool, pkgId, installed, requiredVersion);
                 }
-                verbose && _check(pkgId, installedMoc, requiredMoc);
             }
         }
+        verbose || _check(tool, highestRequiredPkgId, installed, highestRequired);
     }
-    verbose || _check(highestRequiredMocPkgId, installedMoc, highestRequiredMoc);
 }
-function _check(pkgId, installedMoc, requiredMoc) {
-    let comp = installedMoc.compare(requiredMoc);
-    if (comp < 0) {
-        console.log(chalk.yellow(`moc version does not meet the requirements of ${pkgId}`));
-        console.log(chalk.yellow(`  Required: >= ${requiredMoc.format()}`));
-        console.log(chalk.yellow(`  Installed:   ${installedMoc.format()}`));
+function _check(tool, pkgId, installed, required) {
+    if (!pkgId || installed.compare(required) >= 0) {
+        return;
     }
+    console.log(chalk.yellow(`${tool} version does not meet the requirements of ${pkgId}`));
+    console.log(chalk.yellow(`  Required: >= ${required.format()}`));
+    console.log(chalk.yellow(`  Installed:   ${installed.format()}`));
 }

package/dist/cli.js

@@ -395,13 +395,15 @@ program
     .command("bench [filter]")
     .description("Run benchmarks")
     .addOption(new Option("--replica <replica>", "Which replica to use to run benchmarks (`dfx` is deprecated; prefer `pocket-ic`)").choices(["dfx", "pocket-ic"]))
-    .addOption(new Option("--gc <gc>", "Garbage collector")
+    .addOption(new Option("--gc <gc>", "Garbage collector. Under enhanced orthogonal persistence (the default) the GC is fixed to `incremental`; selecting `copying`, `compacting`, or `generational` implies `--legacy-persistence`")
     .choices(["copying", "compacting", "generational", "incremental"])
-    .default("copying"))
+    .default("incremental"))
     .addOption(new Option("--save", "Save benchmark results to .bench/<filename>.json"))
     .addOption(new Option("--compare", "Run benchmark and compare results with .bench/<filename>.json"))
     // .addOption(new Option('--force-gc', 'Force GC'))
-    .addOption(new Option("--verbose", "Print the benchmark pipeline (compiler, replica, GC, optimization) and stream compiler/replica output, including dfx optimization warnings"))
+    .addOption(new Option("--query", "Measure each cell in a query call (how `query` methods run on the IC: no GC). Only for benchmarks whose runner is synchronous (no inter-canister calls)"))
+    .addOption(new Option("--legacy-persistence", "Compile benchmark canisters under legacy persistence instead of enhanced orthogonal persistence (the default)"))
+    .addOption(new Option("--verbose", "Print the benchmark pipeline (compiler, replica, GC, context, persistence, profile, optimization) and stream compiler/replica output, including dfx optimization warnings"))
     .action(async (filter, options) => {
     checkConfigFile(true);
     await installAll({

package/dist/commands/bench.d.ts

@@ -7,6 +7,8 @@ type BenchOptions = {
     compilerVersion: string;
     gc: "copying" | "compacting" | "generational" | "incremental";
     forceGc: boolean;
+    query: boolean;
+    legacyPersistence: boolean;
     save: boolean;
     compare: boolean;
     verbose: boolean;

package/dist/commands/bench.js

@@ -29,8 +29,10 @@ export async function bench(filter = "", optionsArg = {}) {
         replicaVersion: "",
         compiler: "moc",
         compilerVersion: getMocVersion(true),
-        gc: "copying",
+        gc: "incremental",
         forceGc: true,
+        query: false,
+        legacyPersistence: false,
         save: false,
         compare: false,
         verbose: false,
@@ -67,10 +69,17 @@ export async function bench(filter = "", optionsArg = {}) {
         let optimize = replicaType === "dfx" || replicaType === "dfx-pocket-ic"
             ? 'dfx `optimize: "cycles"` (ic-wasm) on deploy'
             : "none (raw moc output)";
+        let legacyGc = isLegacyGc(options.gc);
+        let effectiveLegacyPersistence = options.legacyPersistence || legacyGc;
         console.log(chalk.gray("Benchmark pipeline:"));
         console.log(chalk.gray(`  compiler:  moc ${options.compilerVersion}`));
         console.log(chalk.gray(`  replica:   ${replicaType}${options.replicaVersion ? ` ${options.replicaVersion}` : ""}`));
         console.log(chalk.gray(`  gc:        ${options.gc}${options.forceGc ? " (forced)" : ""}`));
+        console.log(chalk.gray(`  context:   ${options.query ? "query" : "update"}`));
+        console.log(chalk.gray(`  persistence: ${effectiveLegacyPersistence ? "legacy" : "enhanced"}`));
+        if (legacyGc && !options.legacyPersistence) {
+            console.log(chalk.gray(`  (gc '${options.gc}' only exists under legacy persistence; enabling --legacy-persistence)`));
+        }
         console.log(chalk.gray(`  profile:   ${options.profile}`));
         console.log(chalk.gray(`  optimize:  ${optimize}`));
     }
@@ -186,16 +195,26 @@ function computeDiffAll(currentResults, prevResults, rows, cols) {
     }
     return diff;
 }
+// Collectors that only exist under legacy persistence. moc 0.15+ fixes the GC to
+// incremental under enhanced orthogonal persistence and rejects these there.
+function isLegacyGc(gc) {
+    return gc === "copying" || gc === "compacting" || gc === "generational";
+}
 function getMocArgs(options) {
     let args = "";
-    if (options.compilerVersion &&
-        new SemVer(options.compilerVersion).compare("0.15.0") >= 0) {
+    let mocAtLeast015 = !!options.compilerVersion &&
+        new SemVer(options.compilerVersion).compare("0.15.0") >= 0;
+    // Legacy collectors require legacy persistence; moc < 0.15 is already legacy
+    // and has no --legacy-persistence flag.
+    let useLegacyPersistence = options.legacyPersistence || isLegacyGc(options.gc);
+    if (useLegacyPersistence && mocAtLeast015) {
         args += " --legacy-persistence";
     }
     if (options.forceGc) {
         args += " --force-gc";
     }
-    if (options.gc) {
+    // Under EOP the GC is fixed; only pass a collector flag where it's selectable.
+    if (options.gc && (useLegacyPersistence || !mocAtLeast015)) {
         args += ` --${options.gc}-gc`;
     }
     if (options.profile === "Debug") {
@@ -386,10 +405,14 @@ async function runBenchFile(file, options, replica) {
     if (canUpdateLog) {
         log();
     }
-    // run all cells
+    // run all cells. `--query` measures in query context (how `query` methods
+    // actually run on the IC: no GC), at the cost of not supporting benches whose
+    // runner performs async calls. Otherwise use the update path.
     for (let [rowIndex, row] of schema.rows.entries()) {
         for (let [colIndex, col] of schema.cols.entries()) {
-            let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
+            let res = options.query
+                ? await actor.runCellQuery(BigInt(rowIndex), BigInt(colIndex))
+                : await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
             results.set(`${row}:${col}`, res);
             // @ts-ignore
             instructionsCells[rowIndex][colIndex] = res.instructions;

package/dist/commands/build.js

@@ -4,7 +4,7 @@ import { exists } from "fs-extra";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { lock, unlockSync } from "proper-lockfile";
-import { cliError } from "../error.js";
+import { cliError, cliExit } from "../error.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
 import { filterCanisters, resolveCanisterConfigs, } from "../helpers/resolve-canisters.js";
 import { BUILD_MANAGED_FLAGS, prepareMocArgs } from "../helpers/moc-args.js";
@@ -107,7 +107,7 @@ export async function build(canisterNames, options) {
                             console.error(result.stdout);
                         }
                     }
-                    cliError(`Build failed for canister ${canisterName} (exit code: ${result.exitCode})`);
+                    cliExit(result.exitCode ?? 1, `Build failed for canister ${canisterName} (exit code: ${result.exitCode})`);
                 }
                 if (options.verbose && result.stdout && result.stdout.trim()) {
                     console.log(result.stdout);

package/dist/commands/check-stable.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, mkdtempSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import chalk from "chalk";
 import { execa } from "execa";
-import { cliError } from "../error.js";
+import { cliError, cliExit } from "../error.js";
 import { getCheckLimitPendingIssue, prepareMigrationArgs, reportCheckLimitPendingIssue, } from "../helpers/migrations.js";
 import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
 import { filterCanisters, looksLikeFile, resolveCanisterConfigs, resolveSingleCanister, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
@@ -146,7 +146,7 @@ export async function runStableCheck(params) {
             if (result.stderr) {
                 console.error(result.stderr);
             }
-            cliError(`✗ Stable compatibility check failed for canister '${canisterName}'`);
+            cliExit(result.exitCode ?? 1, `✗ Stable compatibility check failed for canister '${canisterName}'`);
         }
         console.log(chalk.green(`✓ Stable compatibility check passed for canister '${canisterName}'`));
     }
@@ -178,7 +178,7 @@ async function generateStableTypes(mocPath, moFile, outputPath, sources, globalM
         if (result.stderr) {
             console.error(result.stderr);
         }
-        cliError(`Failed to generate stable types for ${moFile} (exit code: ${result.exitCode})`);
+        cliExit(result.exitCode ?? 1, `Failed to generate stable types for ${moFile} (exit code: ${result.exitCode})`);
     }
     await rm(wasmPath, { force: true });
     return outputPath;

package/dist/commands/check.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import chalk from "chalk";
 import { execa } from "execa";
-import { cliError } from "../error.js";
+import { cliError, cliExit } from "../error.js";
 import { getGlobalMocArgs, getRootDir, readConfig, resolveConfigPath, } from "../mops.js";
 import { autofixMotoko } from "../helpers/autofix-motoko.js";
 import { withFixLock } from "../helpers/fix-lock.js";
@@ -127,7 +127,7 @@ async function checkCanisters(config, canisters, options) {
                     reject: false,
                 });
                 if (result.exitCode !== 0) {
-                    cliError(`✗ Check failed for canister ${canisterName} (exit code: ${result.exitCode})`);
+                    cliExit(result.exitCode ?? 1, `✗ Check failed for canister ${canisterName} (exit code: ${result.exitCode})`);
                 }
                 console.log(chalk.green(`✓ ${canisterName}`));
             }
@@ -189,7 +189,7 @@ async function checkFiles(config, files, options) {
                 reject: false,
             });
             if (result.exitCode !== 0) {
-                cliError(`✗ Check failed for file ${file} (exit code: ${result.exitCode})`);
+                cliExit(result.exitCode ?? 1, `✗ Check failed for file ${file} (exit code: ${result.exitCode})`);
             }
             console.log(chalk.green(`✓ ${file}`));
         }

package/dist/commands/generate.js

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import { execa } from "execa";
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
-import { cliError } from "../error.js";
+import { cliError, cliExit } from "../error.js";
 import { filterCanisters, resolveCanisterConfigs, } from "../helpers/resolve-canisters.js";
 import { GENERATE_CANDID_MANAGED_FLAGS, prepareMocArgs, } from "../helpers/moc-args.js";
 import { getRootDir, readConfig, resolveConfigPath, writeConfig, } from "../mops.js";
@@ -60,7 +60,7 @@ export async function generateCandid(canisterNames, options) {
                         console.error(result.stdout);
                     }
                 }
-                cliError(`Failed to generate Candid for canister ${canisterName} (exit code: ${result.exitCode})`);
+                cliExit(result.exitCode ?? 1, `Failed to generate Candid for canister ${canisterName} (exit code: ${result.exitCode})`);
             }
             if (dest.configPath !== null) {
                 const c = (config.canisters ??= {});

package/dist/commands/test/test.js

@@ -98,17 +98,24 @@ export async function test(filter = "", options = {}) {
     else {
         let passed = await runAll(options.reporter, filter, options.mode, replicaType, false, undefined, explicitReplica);
         if (!passed) {
-            process.exit(1);
+            process.exit(maxMocExit >= 2 ? 2 : 1);
         }
     }
 }
 let mocPath = "";
 let wasmtimePath = "";
+let maxMocExit = 0;
+const trackMocExit = (code) => {
+    if (code && code >= 2) {
+        maxMocExit = Math.max(maxMocExit, code);
+    }
+};
 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, explicitReplica = false) {
+    maxMocExit = 0;
     let rootDir = getRootDir();
     let files = [];
     let libFiles = globSync("**/test?(s)/lib.mo", MOTOKO_GLOB_CONFIG);
@@ -217,7 +224,7 @@ export async function testWithReporter(reporterName, filter = "", defaultMode =
                     }
                     throw error;
                 });
-                pipeMMF(proc, mmf).then(resolve);
+                pipeMMF(proc, mmf, trackMocExit).then(resolve);
             }
             // build and run wasm
             else if (mode === "wasi") {
@@ -230,7 +237,7 @@ export async function testWithReporter(reporterName, filter = "", defaultMode =
                     }
                     throw error;
                 });
-                pipeMMF(buildProc, mmf)
+                pipeMMF(buildProc, mmf, trackMocExit)
                     .then(async () => {
                     if (mmf.failed > 0) {
                         return;
@@ -288,7 +295,7 @@ export async function testWithReporter(reporterName, filter = "", defaultMode =
                     }
                     throw error;
                 });
-                pipeMMF(buildProc, mmf)
+                pipeMMF(buildProc, mmf, trackMocExit)
                     .then(async () => {
                     if (mmf.failed > 0) {
                         return;

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

@@ -4,4 +4,4 @@ import { MMF1 } from "./mmf1.js";
 export declare function absToRel(p: string): string;
 export declare function pipeStdoutToMMF(stdout: Readable, mmf: MMF1): void;
 export declare function pipeStderrToMMF(stderr: Readable, mmf: MMF1, dir?: string): void;
-export declare function pipeMMF(proc: ChildProcessWithoutNullStreams, mmf: MMF1): Promise<void>;
+export declare function pipeMMF(proc: ChildProcessWithoutNullStreams, mmf: MMF1, onClose?: (code: number | null) => void): Promise<void>;

package/dist/commands/test/utils.js

@@ -49,11 +49,10 @@ export function pipeStderrToMMF(stderr, mmf, dir = "") {
         mmf.fail(text);
     });
 }
-export function pipeMMF(proc, mmf) {
+export function pipeMMF(proc, mmf, onClose) {
     return new Promise((resolve) => {
         pipeStdoutToMMF(proc.stdout, mmf);
         pipeStderrToMMF(proc.stderr, mmf);
-        // exit
         proc.on("close", (code) => {
             if (code === 0) {
                 mmf.strategy !== "print" && mmf.pass();
@@ -61,6 +60,7 @@ export function pipeMMF(proc, mmf) {
             else if (code !== 1) {
                 mmf.fail(`unknown exit code: ${code}`);
             }
+            onClose?.(code ?? null);
             resolve();
         });
     });

package/dist/commands/toolchain/index.js

@@ -259,9 +259,7 @@ async function update(tool) {
         let oldVersion = config.toolchain[tool];
         config.toolchain[tool] = version;
         writeConfig(config);
-        if (tool === "moc") {
-            await checkRequirements();
-        }
+        await checkRequirements();
         if (oldVersion === version) {
             console.log(`Latest ${tool} ${version} is already installed`);
         }

package/dist/error.d.ts

@@ -1 +1,2 @@
 export declare function cliError(...args: unknown[]): never;
+export declare function cliExit(code: number, ...args: unknown[]): never;

package/dist/error.js

@@ -3,3 +3,7 @@ export function cliError(...args) {
     console.error(chalk.red(...args));
     process.exit(1);
 }
+export function cliExit(code, ...args) {
+    console.error(chalk.red(...args));
+    process.exit(code || 1);
+}

package/dist/helpers/get-lintoko-version.d.ts

@@ -0,0 +1,3 @@
+import { type SemVer } from "semver";
+export declare function getLintokoSemVer(): SemVer | null;
+export declare function getLintokoVersion(throwOnError?: boolean): string;

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/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.2",
+  "version": "2.16.1",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",

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

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

package/dist/tests/bench.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, jest, test } from "@jest/globals";
+import { rmSync } from "node:fs";
+import path from "path";
+import { cli } from "./helpers";
+// Pin moc 1.3.0 (≥ 0.15) to exercise the EOP path — this repo's own mops.toml
+// uses moc 0.14.14, so the default bench run is never EOP-tested here.
+describe("bench", () => {
+    jest.setTimeout(180_000);
+    test("runs under EOP with the default gc", async () => {
+        const cwd = path.join(import.meta.dirname, "bench");
+        try {
+            const result = await cli(["bench"], { cwd });
+            expect(result.stderr).not.toContain("--copying-gc is not supported");
+            expect(result.stderr).not.toContain("Invalid compiler flag combination");
+            expect(result.exitCode).toBe(0);
+        }
+        finally {
+            rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+        }
+    });
+});

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/error.ts

@@ -4,3 +4,8 @@ export function cliError(...args: unknown[]): never {
   console.error(chalk.red(...args));
   process.exit(1);
 }
+
+export function cliExit(code: number, ...args: unknown[]): never {
+  console.error(chalk.red(...args));
+  process.exit(code || 1);
+}

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/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.2",
+  "version": "2.16.1",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",

package/tests/bench/bench/sanity.bench.mo

@@ -0,0 +1,27 @@
+// Exercises the bench pipeline under EOP; the template only needs
+// init() -> { getVersion; getSchema; runCell }, so no mo:bench dep.
+module {
+  type Schema = {
+    name : Text;
+    description : Text;
+    rows : [Text];
+    cols : [Text];
+  };
+
+  class Bench(schema : Schema, run : (Nat, Nat) -> ()) {
+    public func getVersion() : Nat = 1;
+    public func getSchema() : Schema = schema;
+    public let runCell = run;
+  };
+
+  public func init() : Bench {
+    let schema : Schema = {
+      name = "Sanity";
+      description = "Trivial bench to exercise the mops bench pipeline under EOP";
+      rows = ["a"];
+      cols = ["1"];
+    };
+    func run(_ri : Nat, _ci : Nat) {};
+    Bench(schema, run);
+  };
+};

package/tests/bench/mops.toml

@@ -0,0 +1,6 @@
+[dependencies]
+core = "2.0.0"
+
+[toolchain]
+moc = "1.3.0"
+pocket-ic = "12.0.0"

package/tests/bench.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, jest, test } from "@jest/globals";
+import { rmSync } from "node:fs";
+import path from "path";
+import { cli } from "./helpers";
+
+// Pin moc 1.3.0 (≥ 0.15) to exercise the EOP path — this repo's own mops.toml
+// uses moc 0.14.14, so the default bench run is never EOP-tested here.
+describe("bench", () => {
+  jest.setTimeout(180_000);
+
+  test("runs under EOP with the default gc", async () => {
+    const cwd = path.join(import.meta.dirname, "bench");
+    try {
+      const result = await cli(["bench"], { cwd });
+      expect(result.stderr).not.toContain("--copying-gc is not supported");
+      expect(result.stderr).not.toContain("Invalid compiler flag combination");
+      expect(result.exitCode).toBe(0);
+    } finally {
+      rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+    }
+  });
+});

package/tests/lint-extra-example-rules/lint/migration-self-contained/migration-self-contained.toml

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

package/tests/lint-extra-example-rules/mops.toml

@@ -5,4 +5,4 @@ lintoko = "0.7.0"
 "src/Main.mo" = ["lint/no-types"]
 "src/Types.mo" = ["lint/types-only"]
 "src/Migration.mo" = ["lint/migration-only"]
-"migrations/**" = ["lint/migration-self-contained"]
+"migrations/*.mo" = ["lint/migration-self-contained"]

package/tests/requirements-lintoko/mops.toml

@@ -0,0 +1,5 @@
+[dependencies]
+my-pkg = "0.1.0"
+
+[toolchain]
+lintoko = "0.7.0"

package/tests/requirements.test.ts

@@ -0,0 +1,66 @@
+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: string;
+
+  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/types.ts

@@ -78,6 +78,7 @@ export type Tool = "moc" | "wasmtime" | "pocket-ic" | "lintoko";
 
 export type Requirements = {
   moc?: string;
+  lintoko?: string;
 };
 
 // export type Format = {