ic-mops 2.9.0 → 2.11.0

package/dist/commands/migrate.js

@@ -0,0 +1,104 @@
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import chalk from "chalk";
+import { cliError } from "../error.js";
+import { getNextMigrationFile, validateMigrationsConfig, validateNextMigrationOrder, } from "../helpers/migrations.js";
+import { resolveCanisterConfigs } from "../helpers/resolve-canisters.js";
+import { readConfig, resolveConfigPath } from "../mops.js";
+function resolveMigrationCanister(canisterName) {
+    const config = readConfig();
+    const canisters = resolveCanisterConfigs(config);
+    const withMigrations = Object.entries(canisters).filter(([, c]) => c.migrations);
+    if (withMigrations.length === 0) {
+        cliError("No canisters with [migrations] config found in mops.toml.\n" +
+            "Add a [canisters.<name>.migrations] section first:\n\n" +
+            "  [canisters.backend.migrations]\n" +
+            '  chain = "migrations"\n' +
+            '  next = "next-migration"   # required for migrate new/freeze');
+    }
+    if (canisterName) {
+        const canister = canisters[canisterName];
+        if (!canister) {
+            cliError(`Canister '${canisterName}' not found in mops.toml. Available: ${Object.keys(canisters).join(", ")}`);
+        }
+        if (!canister.migrations) {
+            cliError(`Canister '${canisterName}' has no [canisters.${canisterName}.migrations] config in mops.toml`);
+        }
+        return { name: canisterName, canister };
+    }
+    if (withMigrations.length > 1) {
+        cliError(`Multiple canisters with [migrations] config. Please specify one: ${withMigrations.map(([n]) => n).join(", ")}`);
+    }
+    return { name: withMigrations[0][0], canister: withMigrations[0][1] };
+}
+const VALID_NAME_RE = /^[A-Za-z][A-Za-z0-9_]*$/;
+function generateTimestamp() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return (`${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}` +
+        `_${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`);
+}
+const MIGRATION_TEMPLATE = `module {
+  public func migration(old : {}) : {} {
+    {}
+  }
+}
+`;
+export async function migrateNew(name, canisterName) {
+    if (!VALID_NAME_RE.test(name)) {
+        cliError(`Invalid migration name: "${name}"\n` +
+            "Name must start with a letter and contain only letters, digits, and underscores.");
+    }
+    const { name: resolvedName, canister } = resolveMigrationCanister(canisterName);
+    const migrations = canister.migrations;
+    validateMigrationsConfig(migrations, resolvedName);
+    if (!migrations.next) {
+        cliError(`[canisters.${resolvedName}.migrations] is missing the "next" field.\n` +
+            'Add next = "next-migration" to use `mops migrate new/freeze`.');
+    }
+    const chainDir = resolveConfigPath(migrations.chain);
+    const nextDir = resolveConfigPath(migrations.next);
+    const existingNext = existsSync(nextDir)
+        ? getNextMigrationFile(nextDir)
+        : null;
+    if (existingNext) {
+        cliError(`A next migration already exists: ${existingNext}\n` +
+            "Freeze it first with `mops migrate freeze`.");
+    }
+    const timestamp = generateTimestamp();
+    const fileName = `${timestamp}_${name}.mo`;
+    validateNextMigrationOrder(chainDir, fileName);
+    if (!existsSync(chainDir)) {
+        mkdirSync(chainDir, { recursive: true });
+    }
+    if (!existsSync(nextDir)) {
+        mkdirSync(nextDir, { recursive: true });
+    }
+    const filePath = join(nextDir, fileName);
+    await writeFile(filePath, MIGRATION_TEMPLATE);
+    console.log(chalk.green(`✓ Created migration: ${filePath}`));
+}
+export async function migrateFreeze(canisterName) {
+    const { name: resolvedName, canister } = resolveMigrationCanister(canisterName);
+    const migrations = canister.migrations;
+    validateMigrationsConfig(migrations, resolvedName);
+    if (!migrations.next) {
+        cliError(`[canisters.${resolvedName}.migrations] is missing the "next" field.\n` +
+            'Add next = "next-migration" to use `mops migrate new/freeze`.');
+    }
+    const chainDir = resolveConfigPath(migrations.chain);
+    const nextDir = resolveConfigPath(migrations.next);
+    const nextFile = existsSync(nextDir) ? getNextMigrationFile(nextDir) : null;
+    if (!nextFile) {
+        cliError("No next migration to freeze. Create one with `mops migrate new <Name>`.");
+    }
+    validateNextMigrationOrder(chainDir, nextFile);
+    if (!existsSync(chainDir)) {
+        mkdirSync(chainDir, { recursive: true });
+    }
+    const src = join(nextDir, nextFile);
+    const dest = join(chainDir, nextFile);
+    renameSync(src, dest);
+    console.log(chalk.green(`✓ Frozen migration: ${nextFile} → ${chainDir}/`));
+}

package/dist/declarations/main/main.did

@@ -42,6 +42,11 @@ type StreamingCallbackResponse =
  };
 type StreamingCallback = func (StreamingToken) ->
                           (opt StreamingCallbackResponse) query;
+type StructureStats = 
+ record {
+   bytes: nat;
+   count: nat;
+ };
 type StorageStats = 
  record {
    cyclesBalance: nat;
@@ -272,6 +277,38 @@ type PackageChanges =
    prevDocsCoverage: float64;
    tests: TestsChanges;
  };
+type MemoryStats = 
+ record {
+   dailySnapshots: StructureStats;
+   dailySnapshotsByPackageId: StructureStats;
+   dailySnapshotsByPackageName: StructureStats;
+   dailyTempRecords: StructureStats;
+   downloadsByPackageId: StructureStats;
+   downloadsByPackageName: StructureStats;
+   fileIdsByPackage: StructureStats;
+   hashByFileId: StructureStats;
+   highestConfigs: StructureStats;
+   maintainersByPackage: StructureStats;
+   ownersByPackage: StructureStats;
+   packageBenchmarks: StructureStats;
+   packageConfigs: StructureStats;
+   packageDocsCoverage: StructureStats;
+   packageFileStats: StructureStats;
+   packageNotes: StructureStats;
+   packagePublications: StructureStats;
+   packageTestStats: StructureStats;
+   packageVersions: StructureStats;
+   rtsHeapSize: nat;
+   rtsMemorySize: nat;
+   names: StructureStats;
+   storageByFileId: StructureStats;
+   storages: StructureStats;
+   users: StructureStats;
+   weeklySnapshots: StructureStats;
+   weeklySnapshotsByPackageId: StructureStats;
+   weeklySnapshotsByPackageName: StructureStats;
+   weeklyTempRecords: StructureStats;
+ };
 type Main = 
  service {
    addMaintainer: (packageName: PackageName, newMaintainer: principal) ->
@@ -311,6 +348,7 @@ type Main =
           SemverPart;
         }) -> (Result_6) query;
    getHighestVersion: (name: PackageName) -> (Result_5) query;
+   getMemoryStats: () -> (MemoryStats) query;
    getMostDownloadedPackages: () -> (vec PackageSummary) query;
    getMostDownloadedPackagesIn7Days: () -> (vec PackageSummary) query;
    getNewPackages: () -> (vec PackageSummary) query;

package/dist/declarations/main/main.did.d.ts

@@ -45,6 +45,41 @@ export interface HttpRequestResult {
   'body' : Uint8Array | number[],
   'headers' : Array<HttpHeader>,
 }
+export interface StructureStats {
+  'count' : bigint,
+  'bytes' : bigint,
+}
+export interface MemoryStats {
+  'rtsHeapSize' : bigint,
+  'rtsMemorySize' : bigint,
+  'packageVersions' : StructureStats,
+  'packageConfigs' : StructureStats,
+  'highestConfigs' : StructureStats,
+  'packagePublications' : StructureStats,
+  'ownersByPackage' : StructureStats,
+  'maintainersByPackage' : StructureStats,
+  'fileIdsByPackage' : StructureStats,
+  'hashByFileId' : StructureStats,
+  'packageFileStats' : StructureStats,
+  'packageTestStats' : StructureStats,
+  'packageBenchmarks' : StructureStats,
+  'packageNotes' : StructureStats,
+  'packageDocsCoverage' : StructureStats,
+  'downloadsByPackageName' : StructureStats,
+  'downloadsByPackageId' : StructureStats,
+  'dailySnapshots' : StructureStats,
+  'weeklySnapshots' : StructureStats,
+  'dailySnapshotsByPackageName' : StructureStats,
+  'dailySnapshotsByPackageId' : StructureStats,
+  'weeklySnapshotsByPackageName' : StructureStats,
+  'weeklySnapshotsByPackageId' : StructureStats,
+  'dailyTempRecords' : StructureStats,
+  'weeklyTempRecords' : StructureStats,
+  'storages' : StructureStats,
+  'storageByFileId' : StructureStats,
+  'users' : StructureStats,
+  'names' : StructureStats,
+}
 export interface Main {
   'addMaintainer' : ActorMethod<[PackageName, Principal], Result_3>,
   'addOwner' : ActorMethod<[PackageName, Principal], Result_3>,
@@ -77,6 +112,7 @@ export interface Main {
     Result_6
   >,
   'getHighestVersion' : ActorMethod<[PackageName], Result_5>,
+  'getMemoryStats' : ActorMethod<[], MemoryStats, 'query'>,
   'getMostDownloadedPackages' : ActorMethod<[], Array<PackageSummary>>,
   'getMostDownloadedPackagesIn7Days' : ActorMethod<[], Array<PackageSummary>>,
   'getNewPackages' : ActorMethod<[], Array<PackageSummary>>,

package/dist/declarations/main/main.did.js

@@ -196,6 +196,41 @@ export const idlFactory = ({ IDL }) => {
     'cyclesBalance' : IDL.Nat,
     'memorySize' : IDL.Nat,
   });
+  const StructureStats = IDL.Record({
+    'count' : IDL.Nat,
+    'bytes' : IDL.Nat,
+  });
+  const MemoryStats = IDL.Record({
+    'rtsHeapSize' : IDL.Nat,
+    'rtsMemorySize' : IDL.Nat,
+    'packageVersions' : StructureStats,
+    'packageConfigs' : StructureStats,
+    'highestConfigs' : StructureStats,
+    'packagePublications' : StructureStats,
+    'ownersByPackage' : StructureStats,
+    'maintainersByPackage' : StructureStats,
+    'fileIdsByPackage' : StructureStats,
+    'hashByFileId' : StructureStats,
+    'packageFileStats' : StructureStats,
+    'packageTestStats' : StructureStats,
+    'packageBenchmarks' : StructureStats,
+    'packageNotes' : StructureStats,
+    'packageDocsCoverage' : StructureStats,
+    'downloadsByPackageName' : StructureStats,
+    'downloadsByPackageId' : StructureStats,
+    'dailySnapshots' : StructureStats,
+    'weeklySnapshots' : StructureStats,
+    'dailySnapshotsByPackageName' : StructureStats,
+    'dailySnapshotsByPackageId' : StructureStats,
+    'weeklySnapshotsByPackageName' : StructureStats,
+    'weeklySnapshotsByPackageId' : StructureStats,
+    'dailyTempRecords' : StructureStats,
+    'weeklyTempRecords' : StructureStats,
+    'storages' : StructureStats,
+    'storageByFileId' : StructureStats,
+    'users' : StructureStats,
+    'names' : StructureStats,
+  });
   const Header = IDL.Tuple(IDL.Text, IDL.Text);
   const Request = IDL.Record({
     'url' : IDL.Text,
@@ -308,6 +343,7 @@ export const idlFactory = ({ IDL }) => {
         ['query'],
       ),
     'getHighestVersion' : IDL.Func([PackageName], [Result_5], ['query']),
+    'getMemoryStats' : IDL.Func([], [MemoryStats], ['query']),
     'getMostDownloadedPackages' : IDL.Func(
         [],
         [IDL.Vec(PackageSummary)],

package/dist/helpers/migrations.d.ts

@@ -0,0 +1,10 @@
+import { MigrationsConfig } from "../types.js";
+export interface MigrationArgsResult {
+    migrationArgs: string[];
+    cleanup: () => Promise<void>;
+}
+export declare function getMigrationFiles(dir: string): string[];
+export declare function getNextMigrationFile(nextDir: string): string | null;
+export declare function validateNextMigrationOrder(chainDirOrFiles: string | string[], nextFile: string): void;
+export declare function validateMigrationsConfig(migrations: MigrationsConfig, canisterName: string): void;
+export declare function prepareMigrationArgs(migrations: MigrationsConfig | undefined, canisterName: string, mode: "check" | "build", verbose?: boolean): Promise<MigrationArgsResult>;

package/dist/helpers/migrations.js

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync, readdirSync, symlinkSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { rm } from "node:fs/promises";
+import chalk from "chalk";
+import { cliError } from "../error.js";
+import { resolveConfigPath } from "../mops.js";
+const MIGRATIONS_TEMP_DIR = ".mops/.migrations";
+export function getMigrationFiles(dir) {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    return readdirSync(dir)
+        .filter((f) => f.endsWith(".mo"))
+        .sort();
+}
+export function getNextMigrationFile(nextDir) {
+    if (!existsSync(nextDir)) {
+        return null;
+    }
+    const files = readdirSync(nextDir).filter((f) => f.endsWith(".mo"));
+    if (files.length > 1) {
+        cliError(`next-migration directory must contain at most 1 .mo file, found ${files.length} in ${nextDir}`);
+    }
+    return files[0] ?? null;
+}
+export function validateNextMigrationOrder(chainDirOrFiles, nextFile) {
+    const chainFiles = typeof chainDirOrFiles === "string"
+        ? getMigrationFiles(chainDirOrFiles)
+        : chainDirOrFiles;
+    const lastChainFile = chainFiles[chainFiles.length - 1];
+    if (lastChainFile && nextFile <= lastChainFile) {
+        cliError(`Next migration "${nextFile}" must sort after all files in the chain.\n` +
+            `Last chain file: "${lastChainFile}".\n` +
+            "Use a timestamp prefix (e.g. YYYYMMDD_HHMMSS_Name.mo) to ensure correct ordering.");
+    }
+}
+export function validateMigrationsConfig(migrations, canisterName) {
+    if (!migrations.chain) {
+        cliError(`[canisters.${canisterName}.migrations] is missing required field "chain"`);
+    }
+    for (const field of ["check-limit", "build-limit"]) {
+        const value = migrations[field];
+        if (value !== undefined && (!Number.isInteger(value) || value <= 0)) {
+            cliError(`[canisters.${canisterName}.migrations] ${field} must be a positive integer`);
+        }
+    }
+}
+export async function prepareMigrationArgs(migrations, canisterName, mode, verbose) {
+    const noOp = {
+        migrationArgs: [],
+        cleanup: async () => { },
+    };
+    if (!migrations) {
+        return noOp;
+    }
+    validateMigrationsConfig(migrations, canisterName);
+    const chainDir = resolveConfigPath(migrations.chain);
+    const nextDir = migrations.next
+        ? resolveConfigPath(migrations.next)
+        : undefined;
+    const nextFile = nextDir ? getNextMigrationFile(nextDir) : null;
+    if (!existsSync(chainDir) && !nextFile) {
+        cliError(`Migration chain directory not found: ${chainDir}\n` +
+            "Run `mops migrate new <Name>` to initialize the migration chain.");
+    }
+    const chainFiles = getMigrationFiles(chainDir);
+    if (nextFile) {
+        validateNextMigrationOrder(chainFiles, nextFile);
+    }
+    const allMigrations = chainFiles.map((f) => ({
+        file: f,
+        dir: chainDir,
+    }));
+    if (nextFile && nextDir) {
+        allMigrations.push({ file: nextFile, dir: nextDir });
+    }
+    const limit = mode === "check" ? migrations["check-limit"] : migrations["build-limit"];
+    const isTrimming = limit !== undefined && limit < allMigrations.length;
+    const needsTempDir = nextFile !== null || isTrimming;
+    if (!needsTempDir) {
+        return {
+            migrationArgs: [`--enhanced-migration=${chainDir}`],
+            cleanup: async () => { },
+        };
+    }
+    const tempDir = join(MIGRATIONS_TEMP_DIR, canisterName);
+    await rm(tempDir, { recursive: true, force: true });
+    mkdirSync(tempDir, { recursive: true });
+    const filesToInclude = isTrimming
+        ? allMigrations.slice(-limit)
+        : allMigrations;
+    for (const { file, dir } of filesToInclude) {
+        symlinkSync(resolve(dir, file), join(tempDir, file));
+    }
+    if (verbose) {
+        console.log(chalk.blue("migrations"), chalk.gray(`Prepared ${filesToInclude.length} migration(s) for ${canisterName}` +
+            (isTrimming ? ` (trimmed from ${allMigrations.length})` : "")));
+    }
+    const migrationArgs = [`--enhanced-migration=${tempDir}`];
+    if (isTrimming) {
+        migrationArgs.push("-A=M0254");
+    }
+    return {
+        migrationArgs,
+        cleanup: async () => {
+            await rm(tempDir, { recursive: true, force: true });
+        },
+    };
+}

package/dist/helpers/resolve-canisters.d.ts

@@ -1,7 +1,9 @@
 import { CanisterConfig, Config } from "../types.js";
 export declare function resolveCanisterConfigs(config: Config): Record<string, CanisterConfig>;
-export declare function resolveCanisterEntrypoints(config: Config): string[];
+export declare function filterCanisters(canisters: Record<string, CanisterConfig>, names?: string[]): Record<string, CanisterConfig>;
 export declare function resolveSingleCanister(config: Config, canisterName?: string): {
     name: string;
     canister: CanisterConfig;
 };
+export declare function looksLikeFile(arg: string): boolean;
+export declare function validateCanisterArgs(canister: CanisterConfig, canisterName: string, config?: Config): void;

package/dist/helpers/resolve-canisters.js

@@ -5,11 +5,15 @@ export function resolveCanisterConfigs(config) {
     }
     return Object.fromEntries(Object.entries(config.canisters).map(([name, c]) => typeof c === "string" ? [name, { main: c }] : [name, c]));
 }
-export function resolveCanisterEntrypoints(config) {
-    const canisters = resolveCanisterConfigs(config);
-    return Object.values(canisters)
-        .map((c) => c.main)
-        .filter((main) => Boolean(main));
+export function filterCanisters(canisters, names) {
+    if (!names) {
+        return canisters;
+    }
+    const invalidNames = names.filter((name) => !(name in canisters));
+    if (invalidNames.length) {
+        cliError(`Canister(s) not found in mops.toml: ${invalidNames.join(", ")}. Available: ${Object.keys(canisters).join(", ")}`);
+    }
+    return Object.fromEntries(Object.entries(canisters).filter(([name]) => names.includes(name)));
 }
 export function resolveSingleCanister(config, canisterName) {
     const canisters = resolveCanisterConfigs(config);
@@ -29,3 +33,28 @@ export function resolveSingleCanister(config, canisterName) {
     }
     return { name: names[0], canister: canisters[names[0]] };
 }
+export function looksLikeFile(arg) {
+    return (arg.endsWith(".mo") ||
+        arg.endsWith(".most") ||
+        arg.includes("/") ||
+        arg.includes("\\"));
+}
+export function validateCanisterArgs(canister, canisterName, config) {
+    if (canister.args && typeof canister.args === "string") {
+        cliError(`Canister config 'args' should be an array of strings for canister ${canisterName}`);
+    }
+    if (!canister.migrations) {
+        return;
+    }
+    const flagSources = [
+        [`[canisters.${canisterName}].args`, canister.args],
+        ["[moc].args", config?.moc?.args],
+        ["[build].args", config?.build?.args],
+    ];
+    for (const [section, args] of flagSources) {
+        if (args?.some((a) => a.startsWith("--enhanced-migration"))) {
+            cliError(`Canister '${canisterName}' has [migrations] config but --enhanced-migration in ${section}.\n` +
+                "Remove --enhanced-migration — it is managed automatically when [migrations] is configured.");
+        }
+    }
+}

package/dist/package.json

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

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

@@ -53,6 +53,24 @@ describe("check-stable", () => {
         expect(existsSync(path.join(cwd, "new.most"))).toBe(false);
         expect(existsSync(path.join(cwd, "new.wasm"))).toBe(false);
     });
+    test("[canisters.X].args are passed to moc (enhanced migration)", async () => {
+        const cwd = path.join(import.meta.dirname, "check-stable/canister-args");
+        const result = await cli(["check-stable", "old.most"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    });
+    test("no args checks all canisters with [check-stable] config", async () => {
+        const cwd = path.join(import.meta.dirname, "check/deployed-compatible");
+        const result = await cli(["check-stable"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    });
+    test("canister name filters to specific canister", async () => {
+        const cwd = path.join(import.meta.dirname, "check/deployed-compatible");
+        const result = await cli(["check-stable", "backend"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    });
     test("errors when old file does not exist", async () => {
         const cwd = path.join(import.meta.dirname, "check-stable/compatible");
         const result = await cli(["check-stable", "nonexistent.mo"], { cwd });

package/dist/tests/check.test.js

@@ -34,30 +34,48 @@ describe("check", () => {
         const cwd = path.join(import.meta.dirname, "check/moc-args");
         await cliSnapshot(["check", "Warning.mo"], { cwd }, 1);
     });
-    test("no args falls back to [canisters] entrypoints", async () => {
+    test("no args checks all canisters", async () => {
         const cwd = path.join(import.meta.dirname, "check/canisters");
         await cliSnapshot(["check"], { cwd }, 0);
     });
-    test("canister entrypoint resolved relative to config root when run from subdirectory", async () => {
+    test("canister name filters to specific canister", async () => {
+        const cwd = path.join(import.meta.dirname, "check/canisters");
+        const result = await cli(["check", "backend"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/✓ backend/);
+    });
+    test("canister resolved relative to config root when run from subdirectory", async () => {
         const fixtureRoot = path.join(import.meta.dirname, "check/canisters-subdir");
         const subdir = path.join(fixtureRoot, "src/backend");
         const result = await cli(["check"], { cwd: subdir });
         expect(result.exitCode).toBe(0);
         expect(result.stdout).toMatch(/✓/);
     });
-    test("[moc] args applied when using canister fallback", async () => {
+    test("[moc] args applied to canister check", async () => {
         const cwd = path.join(import.meta.dirname, "check/canisters-moc-args");
         const result = await cli(["check"], { cwd });
         expect(result.exitCode).toBe(1);
         expect(result.stderr).toMatch(/warning \[M0194\]/);
     });
-    test("canister entrypoint with errors", async () => {
+    test("[canisters.X].args applied to canister check", async () => {
+        const cwd = path.join(import.meta.dirname, "check/canisters-canister-args");
+        const result = await cli(["check"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+    });
+    test("canister with errors", async () => {
         const cwd = path.join(import.meta.dirname, "check/canisters-error");
         const result = await cli(["check"], { cwd });
         expect(result.exitCode).toBe(1);
         expect(result.stderr).toMatch(/error/i);
     });
-    test("--fix with canister fallback", async () => {
+    test("invalid canister name errors", async () => {
+        const cwd = path.join(import.meta.dirname, "check/canisters");
+        const result = await cli(["check", "nonexistent"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/not found in mops\.toml/);
+    });
+    test("--fix with canister", async () => {
         const cwd = path.join(import.meta.dirname, "check/canisters");
         const result = await cli(["check", "--fix"], { cwd });
         expect(result.exitCode).toBe(0);

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

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