ic-mops 2.15.2 → 2.16.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Next
 
+## 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

@@ -558,6 +558,18 @@ 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",

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;
@@ -61,6 +63,8 @@ export async function bench(
     compilerVersion: getMocVersion(true),
     gc: "copying",
     forceGc: true,
+    query: false,
+    legacyPersistence: false,
     save: false,
     compare: false,
     verbose: false,
@@ -120,6 +124,14 @@ export async function bench(
         `  gc:        ${options.gc}${options.forceGc ? " (forced)" : ""}`,
       ),
     );
+    console.log(
+      chalk.gray(`  context:   ${options.query ? "query" : "update"}`),
+    );
+    console.log(
+      chalk.gray(
+        `  persistence: ${options.legacyPersistence ? "legacy" : "enhanced"}`,
+      ),
+    );
     console.log(chalk.gray(`  profile:   ${options.profile}`));
     console.log(chalk.gray(`  optimize:  ${optimize}`));
   }
@@ -270,7 +282,12 @@ function computeDiffAll(
 function getMocArgs(options: BenchOptions): string {
   let args = "";
 
+  // Benchmarks compile under enhanced orthogonal persistence (moc's default
+  // since 0.15) — the mode real canisters run. Pass `--legacy-persistence`
+  // only when the user opts in, and only where moc supports the flag (>= 0.15;
+  // legacy is already the default below it).
   if (
+    options.legacyPersistence &&
     options.compilerVersion &&
     new SemVer(options.compilerVersion).compare("0.15.0") >= 0
   ) {
@@ -533,13 +550,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/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

@@ -401,6 +401,8 @@ program
     .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("--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"))
     .action(async (filter, options) => {
     checkConfigFile(true);

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

@@ -31,6 +31,8 @@ export async function bench(filter = "", optionsArg = {}) {
         compilerVersion: getMocVersion(true),
         gc: "copying",
         forceGc: true,
+        query: false,
+        legacyPersistence: false,
         save: false,
         compare: false,
         verbose: false,
@@ -71,6 +73,8 @@ export async function bench(filter = "", optionsArg = {}) {
         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: ${options.legacyPersistence ? "legacy" : "enhanced"}`));
         console.log(chalk.gray(`  profile:   ${options.profile}`));
         console.log(chalk.gray(`  optimize:  ${optimize}`));
     }
@@ -188,7 +192,12 @@ function computeDiffAll(currentResults, prevResults, rows, cols) {
 }
 function getMocArgs(options) {
     let args = "";
-    if (options.compilerVersion &&
+    // Benchmarks compile under enhanced orthogonal persistence (moc's default
+    // since 0.15) — the mode real canisters run. Pass `--legacy-persistence`
+    // only when the user opts in, and only where moc supports the flag (>= 0.15;
+    // legacy is already the default below it).
+    if (options.legacyPersistence &&
+        options.compilerVersion &&
         new SemVer(options.compilerVersion).compare("0.15.0") >= 0) {
         args += " --legacy-persistence";
     }
@@ -386,10 +395,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/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/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.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",

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

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

package/dist/tests/requirements.test.js

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

package/dist/types.d.ts

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

package/helpers/get-lintoko-version.ts

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

package/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.0",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",

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 = {