ic-mops 2.14.0 → 2.15.0

package/dist/commands/deployed.js

@@ -0,0 +1,97 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { copyFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { cliError } from "../error.js";
+import { filterCanisters, resolveCanisterConfigs, } from "../helpers/resolve-canisters.js";
+import { getRootDir, readConfig, resolveConfigPath, writeConfig, } from "../mops.js";
+import { resolveBuildOutputDir } from "./build.js";
+export const DEFAULT_DEPLOYED_DIR = "deployed";
+const EMPTY_ACTOR_MOST = "// Version: 1.0.0\nactor { };\n";
+// `[deployed].dir` and CLI overrides are tracked in two forms:
+//   - `config`: relative to mops.toml, used for display + writing into mops.toml
+//   - `resolved`: relative to cwd, used for fs operations
+function resolveDeployedDir(config, override) {
+    if (override) {
+        const configRel = path.relative(getRootDir(), path.resolve(override)) || ".";
+        return { config: configRel, resolved: override };
+    }
+    const configured = config.deployed?.dir ?? DEFAULT_DEPLOYED_DIR;
+    return { config: configured, resolved: resolveConfigPath(configured) };
+}
+function selectCanisters(canisterNames, config) {
+    if (canisterNames?.length === 0) {
+        cliError("No canisters specified");
+    }
+    const canisters = resolveCanisterConfigs(config);
+    if (!Object.keys(canisters).length) {
+        cliError(`No Motoko canisters found in mops.toml configuration`);
+    }
+    return filterCanisters(canisters, canisterNames);
+}
+function warnIfStablePathDiverges(name, stablePath, destMostRel) {
+    if (path.resolve(resolveConfigPath(stablePath)) ===
+        path.resolve(resolveConfigPath(destMostRel))) {
+        return;
+    }
+    console.warn(chalk.yellow(`WARN: [canisters.${name}.check-stable].path = "${stablePath}" ` +
+        `does not match where \`mops deployed\` writes ("${destMostRel}"). ` +
+        `\`mops check-stable\` won't see updates from \`mops deployed\`.`));
+}
+export async function deployed(canisterNames, options = {}) {
+    const config = readConfig();
+    const filtered = selectCanisters(canisterNames, config);
+    const buildDir = resolveBuildOutputDir(config, options.buildDir);
+    const deployedDir = resolveDeployedDir(config, options.dir);
+    mkdirSync(deployedDir.resolved, { recursive: true });
+    for (const [name, canister] of Object.entries(filtered)) {
+        const sourceMost = path.join(buildDir, `${name}.most`);
+        const destMostRel = path.join(deployedDir.config, `${name}.most`);
+        const destMost = path.join(deployedDir.resolved, `${name}.most`);
+        if (!existsSync(sourceMost)) {
+            cliError(`No built .most at ${sourceMost}. Run \`mops build ${name}\` first.`);
+        }
+        await copyFile(sourceMost, destMost);
+        console.log(chalk.green(`✓ ${sourceMost} → ${destMost}`));
+        const stablePath = canister["check-stable"]?.path;
+        if (stablePath) {
+            warnIfStablePathDiverges(name, stablePath, destMostRel);
+        }
+    }
+}
+export async function deployedInit(canisterNames, options = {}) {
+    const config = readConfig();
+    const filtered = selectCanisters(canisterNames, config);
+    const deployedDir = resolveDeployedDir(config, options.dir);
+    mkdirSync(deployedDir.resolved, { recursive: true });
+    let configChanged = false;
+    for (const [name, canister] of Object.entries(filtered)) {
+        const destMostRel = path.join(deployedDir.config, `${name}.most`);
+        const destMost = path.join(deployedDir.resolved, `${name}.most`);
+        if (!existsSync(destMost)) {
+            await writeFile(destMost, EMPTY_ACTOR_MOST);
+            console.log(chalk.green(`✓ Created baseline ${destMost}`));
+        }
+        const stablePath = canister["check-stable"]?.path;
+        if (!stablePath) {
+            const entry = config.canisters?.[name];
+            if (typeof entry === "string") {
+                config.canisters[name] = {
+                    main: entry,
+                    "check-stable": { path: destMostRel },
+                };
+            }
+            else if (entry) {
+                entry["check-stable"] = { path: destMostRel };
+            }
+            configChanged = true;
+            console.log(chalk.green(`✓ Set [canisters.${name}.check-stable].path = "${destMostRel}"`));
+        }
+        else {
+            warnIfStablePathDiverges(name, stablePath, destMostRel);
+        }
+    }
+    if (configChanged) {
+        writeConfig(config);
+    }
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1,6 @@
+export interface GenerateCandidOptions {
+    output?: string;
+    verbose?: boolean;
+    extraArgs?: string[];
+}
+export declare function generateCandid(canisterNames: string[] | undefined, options: GenerateCandidOptions): Promise<void>;

package/dist/commands/generate.js

@@ -0,0 +1,124 @@
+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 { 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";
+import { toolchain } from "./toolchain/index.js";
+export async function generateCandid(canisterNames, options) {
+    if (canisterNames?.length === 0) {
+        cliError("No canisters specified");
+    }
+    const config = readConfig();
+    const canisters = resolveCanisterConfigs(config);
+    if (!Object.keys(canisters).length) {
+        cliError("No Motoko canisters found in mops.toml configuration");
+    }
+    const filtered = filterCanisters(canisters, canisterNames);
+    const filteredEntries = Object.entries(filtered);
+    if (options.output && filteredEntries.length > 1) {
+        cliError("--output / -o is only supported when generating for a single canister");
+    }
+    const mocPath = await toolchain.bin("moc", { fallback: true });
+    const rootDir = getRootDir();
+    let configChanged = false;
+    for (const [canisterName, canister] of filteredEntries) {
+        const dest = resolveDestination(canisterName, canister, canisters, options.output, rootDir);
+        console.log(chalk.blue("generate candid"), chalk.bold(canisterName), chalk.gray(`→ ${dest.fsPath}`));
+        const prepared = await prepareMocArgs(config, canister, canisterName, {
+            mode: "build",
+            managedFlags: GENERATE_CANDID_MANAGED_FLAGS,
+            commandName: "mops generate candid",
+            verbose: options.verbose,
+            extraArgs: options.extraArgs,
+        });
+        try {
+            await mkdir(path.dirname(dest.fsPath), { recursive: true });
+            const args = [
+                "--idl",
+                "-o",
+                dest.fsPath,
+                prepared.motokoPath,
+                ...prepared.args,
+            ];
+            if (options.verbose) {
+                console.log(chalk.gray(mocPath, JSON.stringify(args)));
+            }
+            const result = await execa(mocPath, args, {
+                stdio: options.verbose ? "inherit" : "pipe",
+                reject: false,
+            });
+            if (result.exitCode !== 0) {
+                if (!options.verbose) {
+                    if (result.stderr) {
+                        console.error(chalk.red(result.stderr));
+                    }
+                    if (result.stdout?.trim()) {
+                        console.error(chalk.yellow("Output:"));
+                        console.error(result.stdout);
+                    }
+                }
+                cliError(`Failed to generate Candid for canister ${canisterName} (exit code: ${result.exitCode})`);
+            }
+            if (dest.configPath !== null) {
+                const c = (config.canisters ??= {});
+                const existing = c[canisterName];
+                const obj = typeof existing === "string"
+                    ? { main: existing }
+                    : { ...(existing ?? {}) };
+                obj.candid = dest.configPath;
+                c[canisterName] = obj;
+                configChanged = true;
+            }
+        }
+        finally {
+            await prepared.cleanup();
+        }
+    }
+    if (configChanged) {
+        writeConfig(config);
+    }
+    console.log(chalk.green(`\n✓ Generated Candid for ${filteredEntries.length} canister${filteredEntries.length === 1 ? "" : "s"}`));
+}
+function resolveDestination(canisterName, canister, allCanisters, outputFlag, rootDir) {
+    if (!canister.main) {
+        cliError(`No main file is specified for canister ${canisterName}`);
+    }
+    let fsPath;
+    let configPath;
+    if (outputFlag) {
+        fsPath = outputFlag;
+        configPath = null;
+        const outAbs = path.resolve(fsPath);
+        for (const [otherName, other] of Object.entries(allCanisters)) {
+            if (otherName === canisterName || !other.candid) {
+                continue;
+            }
+            if (path.resolve(rootDir, other.candid) === outAbs) {
+                console.warn(chalk.yellow(`Warning: --output path collides with [canisters.${otherName}].candid (${other.candid}). Sharing a .did between canisters is almost always a mistake.`));
+            }
+        }
+    }
+    else if (canister.candid) {
+        fsPath = resolveConfigPath(canister.candid);
+        configPath = null;
+    }
+    else {
+        // Default: <dirname(main)>/<canisterName>.did, forward slashes for the toml value
+        const mainDir = path.dirname(canister.main).replace(/\\/g, "/");
+        const projectRel = mainDir === "." || mainDir === ""
+            ? `${canisterName}.did`
+            : `${mainDir}/${canisterName}.did`;
+        fsPath = resolveConfigPath(projectRel);
+        configPath = projectRel;
+    }
+    const absPath = path.resolve(fsPath);
+    const dotMopsDir = path.resolve(rootDir, ".mops");
+    if (absPath === dotMopsDir || absPath.startsWith(dotMopsDir + path.sep)) {
+        cliError(`Refusing to write Candid file inside .mops/ (private build cache): ${fsPath}\n` +
+            "Choose a path outside .mops/ — it should be committable and readable by downstream tooling.");
+    }
+    return { fsPath, configPath };
+}

package/dist/commands/lint.d.ts

@@ -6,5 +6,7 @@ export interface LintOptions {
     rules?: string[];
     files?: string[];
     extraArgs: string[];
+    /** Commander `--no-check-limit`: lint the full migration chain. */
+    noCheckLimit?: boolean;
 }
 export declare function lint(filter: string | undefined, options: Partial<LintOptions>): Promise<void>;

package/dist/commands/lint.js

@@ -122,7 +122,7 @@ async function lintImpl(filter, options) {
         ? await toolchain.bin("lintoko")
         : "lintoko";
     const isExplicit = !!filter || !!(options.files && options.files.length > 0);
-    const trimmedMigrations = isExplicit
+    const trimmedMigrations = isExplicit || options.noCheckLimit
         ? new Set()
         : getTrimmedMigrationFiles(config);
     let filesToLint;

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

@@ -1,5 +1,7 @@
 interface MocSpan {
     file: string;
+    byte_start?: number | null;
+    byte_end?: number | null;
     line_start: number;
     column_start: number;
     line_end: number;

package/dist/helpers/autofix-motoko.js

@@ -1,7 +1,7 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { execa } from "execa";
-import { TextDocument, } from "vscode-languageserver-textdocument";
+import { TextDocument } from "vscode-languageserver-textdocument";
 export function parseDiagnostics(stdout) {
     if (!stdout) {
         return [];
@@ -24,25 +24,14 @@ function extractDiagnosticFixes(diagnostics) {
     for (const diag of diagnostics) {
         const editsByFile = new Map();
         for (const span of diag.spans) {
-            if (span.suggestion_applicability === "MachineApplicable" &&
-                span.suggested_replacement !== null) {
-                const file = resolve(span.file);
-                const edits = editsByFile.get(file) ?? [];
-                edits.push({
-                    range: {
-                        start: {
-                            line: span.line_start - 1,
-                            character: span.column_start - 1,
-                        },
-                        end: {
-                            line: span.line_end - 1,
-                            character: span.column_end - 1,
-                        },
-                    },
-                    newText: span.suggested_replacement,
-                });
-                editsByFile.set(file, edits);
+            if (span.suggestion_applicability !== "MachineApplicable" ||
+                span.suggested_replacement === null) {
+                continue;
             }
+            const file = resolve(span.file);
+            const edits = editsByFile.get(file) ?? [];
+            edits.push({ span, newText: span.suggested_replacement });
+            editsByFile.set(file, edits);
         }
         for (const [file, edits] of editsByFile) {
             const existing = result.get(file) ?? [];
@@ -52,32 +41,47 @@ function extractDiagnosticFixes(diagnostics) {
     }
     return result;
 }
-function normalizeRange(range) {
-    const { start, end } = range;
-    if (start.line > end.line ||
-        (start.line === end.line && start.character > end.character)) {
-        return { start: end, end: start };
-    }
-    return range;
-}
 /**
- * Applies diagnostic fixes to a document, processing each diagnostic as
+ * Applies diagnostic fixes to a file's contents, processing each diagnostic as
  * an atomic unit. If any edit from a diagnostic overlaps with an already-accepted
  * edit, the entire diagnostic is skipped (picked up in subsequent iterations).
  * Based on vscode-languageserver-textdocument's TextDocument.applyEdits.
+ *
+ * Edits prefer `byte_start`/`byte_end` (byte-accurate on any UTF-8 source);
+ * falls back to line+column for older moc, which mis-applies on non-ASCII
+ * lines since moc's `column_*` are bytes but LSP expects UTF-16 code units.
  */
-function applyDiagnosticFixes(doc, fixes) {
+function applyDiagnosticFixes(content, fixes) {
+    let buf = null;
+    const byteToOffset = (byteOffset) => {
+        buf ??= Buffer.from(content, "utf8");
+        return buf.subarray(0, byteOffset).toString("utf8").length;
+    };
+    let doc = null;
+    const toOffsetEdit = ({ span, newText }) => {
+        if (span.byte_start != null && span.byte_end != null) {
+            const [s, e] = span.byte_start <= span.byte_end
+                ? [span.byte_start, span.byte_end]
+                : [span.byte_end, span.byte_start];
+            return { start: byteToOffset(s), end: byteToOffset(e), newText };
+        }
+        doc ??= TextDocument.create("inmemory://autofix", "motoko", 0, content);
+        const start = doc.offsetAt({
+            line: span.line_start - 1,
+            character: span.column_start - 1,
+        });
+        const end = doc.offsetAt({
+            line: span.line_end - 1,
+            character: span.column_end - 1,
+        });
+        return start <= end
+            ? { start, end, newText }
+            : { start: end, end: start, newText };
+    };
     const acceptedEdits = [];
     const appliedCodes = [];
     for (const fix of fixes) {
-        const offsets = fix.edits.map((e) => {
-            const range = normalizeRange(e.range);
-            return {
-                start: doc.offsetAt(range.start),
-                end: doc.offsetAt(range.end),
-                newText: e.newText,
-            };
-        });
+        const offsets = fix.edits.map(toOffsetEdit);
         const overlaps = offsets.some((o) => acceptedEdits.some((a) => o.start < a.end && o.end > a.start));
         if (overlaps) {
             continue;
@@ -86,7 +90,6 @@ function applyDiagnosticFixes(doc, fixes) {
         appliedCodes.push(fix.code);
     }
     acceptedEdits.sort((a, b) => a.start - b.start);
-    const text = doc.getText();
     const spans = [];
     let lastOffset = 0;
     for (const edit of acceptedEdits) {
@@ -94,14 +97,14 @@ function applyDiagnosticFixes(doc, fixes) {
             continue;
         }
         if (edit.start > lastOffset) {
-            spans.push(text.substring(lastOffset, edit.start));
+            spans.push(content.substring(lastOffset, edit.start));
         }
         if (edit.newText.length) {
             spans.push(edit.newText);
         }
         lastOffset = edit.end;
     }
-    spans.push(text.substring(lastOffset));
+    spans.push(content.substring(lastOffset));
     return { text: spans.join(""), appliedCodes };
 }
 const MAX_FIX_ITERATIONS = 10;
@@ -124,8 +127,7 @@ export async function autofixMotoko(mocPath, files, mocArgs) {
         let progress = false;
         for (const [file, fixes] of fixesByFile) {
             const original = await readFile(file, "utf-8");
-            const doc = TextDocument.create(`file://${file}`, "motoko", 0, original);
-            const { text: result, appliedCodes } = applyDiagnosticFixes(doc, fixes);
+            const { text: result, appliedCodes } = applyDiagnosticFixes(original, fixes);
             if (result === original) {
                 continue;
             }

package/dist/helpers/migrations.d.ts

@@ -7,7 +7,7 @@ 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>;
+export declare function prepareMigrationArgs(migrations: MigrationsConfig | undefined, canisterName: string, mode: "check" | "build", verbose?: boolean, ignoreLimit?: boolean): Promise<MigrationArgsResult>;
 /**
  * Absolute paths of chain migration files that `mops lint` should skip,
  * mirroring the `check-limit` trimming applied to `moc` during `mops check`.

package/dist/helpers/migrations.js

@@ -68,7 +68,7 @@ export function validateMigrationsConfig(migrations, canisterName) {
  * for moc) and `getTrimmedMigrationFiles` (which feeds `excludedChainFiles`
  * to lint).
  */
-function resolveMigrationChain(migrations, canisterName, mode) {
+function resolveMigrationChain(migrations, canisterName, mode, ignoreLimit = false) {
     validateMigrationsConfig(migrations, canisterName);
     const chainDir = resolveConfigPath(migrations.chain);
     const nextDir = migrations.next
@@ -91,7 +91,11 @@ function resolveMigrationChain(migrations, canisterName, mode) {
     if (nextFile && nextDir) {
         all.push({ file: nextFile, dir: nextDir });
     }
-    const limit = mode === "check" ? migrations["check-limit"] : migrations["build-limit"];
+    const limit = ignoreLimit
+        ? undefined
+        : mode === "check"
+            ? migrations["check-limit"]
+            : migrations["build-limit"];
     const isTrimming = limit !== undefined && limit < all.length;
     const included = isTrimming ? all.slice(-limit) : all;
     // Dropped entries are always a chain-only prefix (next sorts last).
@@ -100,11 +104,11 @@ function resolveMigrationChain(migrations, canisterName, mode) {
         .map((e) => resolve(e.dir, e.file));
     return { chainDir, nextDir, included, excludedChainFiles, isTrimming };
 }
-export async function prepareMigrationArgs(migrations, canisterName, mode, verbose) {
+export async function prepareMigrationArgs(migrations, canisterName, mode, verbose, ignoreLimit = false) {
     if (!migrations) {
         return { migrationArgs: [], cleanup: async () => { } };
     }
-    const { chainDir, nextDir, included, excludedChainFiles, isTrimming } = resolveMigrationChain(migrations, canisterName, mode);
+    const { chainDir, nextDir, included, excludedChainFiles, isTrimming } = resolveMigrationChain(migrations, canisterName, mode, ignoreLimit);
     const hasNext = included.some((e) => e.dir === nextDir);
     const needsTempDir = hasNext || isTrimming;
     if (!needsTempDir) {

package/dist/helpers/moc-args.d.ts

@@ -0,0 +1,25 @@
+import { CanisterConfig, Config } from "../types.js";
+/** Single source of truth for "how moc is invoked for canister X" — keeps
+ * `mops build` and `mops generate candid` in lockstep so the auto-generated
+ * `.did` they each produce stays subtype-compatible with the curated one
+ * embedded by `mops build`. */
+export interface PrepareMocArgsOptions {
+    /** Selects the migration trim limit (`build-limit` vs `check-limit`). */
+    mode: "check" | "build";
+    /** Per-flag hints used when warning about conflicting `args` entries. */
+    managedFlags: Record<string, string>;
+    /** Command label shown in the warning, e.g. "mops build". */
+    commandName: string;
+    verbose?: boolean;
+    extraArgs?: string[];
+}
+export interface PreparedMocArgs {
+    motokoPath: string;
+    /** sources + [moc].args + migration + [build].args + [canisters.x].args + CLI extras. */
+    args: string[];
+    /** Cleans up the migration staging dir; call from a `finally`. */
+    cleanup: () => Promise<void>;
+}
+export declare const BUILD_MANAGED_FLAGS: Record<string, string>;
+export declare const GENERATE_CANDID_MANAGED_FLAGS: Record<string, string>;
+export declare function prepareMocArgs(config: Config, canister: CanisterConfig, canisterName: string, options: PrepareMocArgsOptions): Promise<PreparedMocArgs>;

package/dist/helpers/moc-args.js

@@ -0,0 +1,58 @@
+import chalk from "chalk";
+import { cliError } from "../error.js";
+import { getGlobalMocArgs, resolveConfigPath } from "../mops.js";
+import { sourcesArgs } from "../commands/sources.js";
+import { prepareMigrationArgs } from "./migrations.js";
+import { validateCanisterArgs } from "./resolve-canisters.js";
+export const BUILD_MANAGED_FLAGS = {
+    "-o": "use [build].outputDir in mops.toml or --output flag instead",
+    "-c": "this flag is always set by mops build",
+    "--idl": "this flag is always set by mops build",
+    "--stable-types": "this flag is always set by mops build",
+    "--public-metadata": "this flag is managed by mops build",
+};
+export const GENERATE_CANDID_MANAGED_FLAGS = {
+    "-o": "use the --output flag on `mops generate candid` instead",
+    "-c": "this flag is incompatible with mops generate candid (would also emit .wasm)",
+    "--idl": "this flag is always set by mops generate candid",
+    "--stable-types": "this flag is incompatible with mops generate candid (would also emit .most)",
+};
+export async function prepareMocArgs(config, canister, canisterName, options) {
+    if (!canister.main) {
+        cliError(`No main file is specified for canister ${canisterName}`);
+    }
+    const motokoPath = resolveConfigPath(canister.main);
+    const migration = await prepareMigrationArgs(canister.migrations, canisterName, options.mode, options.verbose);
+    const args = [
+        ...(await sourcesArgs()).flat(),
+        ...getGlobalMocArgs(config),
+        ...migration.migrationArgs,
+        ...collectExtraArgs(config, canister, canisterName, options.managedFlags, options.commandName, options.extraArgs),
+    ];
+    return { motokoPath, args, cleanup: migration.cleanup };
+}
+function collectExtraArgs(config, canister, canisterName, managedFlags, commandName, extraArgs) {
+    const args = [];
+    if (config.build?.args) {
+        if (typeof config.build.args === "string") {
+            cliError(`[build] config 'args' should be an array of strings in mops.toml config file`);
+        }
+        args.push(...config.build.args);
+    }
+    if (canister.args) {
+        validateCanisterArgs(canister, canisterName, config);
+        args.push(...canister.args);
+    }
+    if (extraArgs) {
+        args.push(...extraArgs);
+    }
+    const warned = new Set();
+    for (const arg of args) {
+        const hint = managedFlags[arg];
+        if (hint && !warned.has(arg)) {
+            warned.add(arg);
+            console.warn(chalk.yellow(`Warning: '${arg}' in args for canister ${canisterName} may conflict with ${commandName} — ${hint}`));
+        }
+    }
+    return args;
+}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",
@@ -55,7 +55,7 @@
     "markdown-table": "3.0.4",
     "mdast-util-from-markdown": "2.0.2",
     "mdast-util-to-markdown": "2.1.2",
-    "minimatch": "10.2.4",
+    "minimatch": "10.2.5",
     "ncp": "2.0.0",
     "octokit": "3.1.2",
     "pem-file": "1.0.1",
@@ -69,7 +69,7 @@
     "semver": "7.7.1",
     "stream-to-promise": "3.0.0",
     "string-width": "7.2.0",
-    "tar": "7.5.11",
+    "tar": "7.5.16",
     "terminal-size": "4.0.0",
     "vscode-languageserver-textdocument": "1.0.12"
   },
@@ -85,13 +85,13 @@
     "@types/proper-lockfile": "4.1.4",
     "@types/semver": "7.5.8",
     "@types/stream-to-promise": "2.2.4",
-    "@types/tar": "6.1.13",
-    "esbuild": "0.23.1",
+    "@types/tar": "7.0.87",
+    "esbuild": "0.28.1",
     "eslint": "8.57.0",
     "npm-run-all": "4.1.5",
     "rexreplace": "7.1.13",
     "ts-jest": "29.4.5",
-    "tsx": "4.19.2",
+    "tsx": "4.22.4",
     "typescript": "5.9.2",
     "wasm-pack": "0.15.0"
   }

package/dist/tests/check-fix-utf8.test.d.ts

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

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

@@ -0,0 +1,38 @@
+import { describe, expect, test, beforeAll } from "@jest/globals";
+import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import path from "path";
+import { cli, normalizePaths } from "./helpers";
+// Regression: --fix must apply byte-accurately on UTF-8 source. The fixture
+// pins a moc version that emits `byte_start`/`byte_end` so the byte path is
+// exercised; without those fields the fixer over-deletes on multi-byte lines
+// (e.g. `Char.toNat32(c)` after a `"京"` on the same line losing its `)`).
+describe("check --fix (utf-8 source)", () => {
+    const fixDir = path.join(import.meta.dirname, "check/fix-utf8");
+    const runDir = path.join(fixDir, "run");
+    const warningFlags = "-W=M0236";
+    beforeAll(() => {
+        for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
+            unlinkSync(path.join(runDir, file));
+        }
+    });
+    test("multi-byte characters do not corrupt the fix", async () => {
+        const src = "multibyte.mo";
+        const runFilePath = path.join(runDir, src);
+        cpSync(path.join(fixDir, src), runFilePath);
+        const fixResult = await cli(["check", runFilePath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(normalizePaths(fixResult.stdout)).toMatchSnapshot("fix output");
+        const fixedContent = readFileSync(runFilePath, "utf-8");
+        expect(fixedContent).toMatchSnapshot("fixed file");
+        // Concrete byte-accuracy assertions: every Char.toNat32 call must be
+        // rewritten to dot notation, with the multi-byte literal before it intact
+        // and the trailing `)` preserved (the original regression: 京/💩 used to
+        // drop it).
+        expect(fixedContent).toContain('"A" # debug_show (c.toNat32());');
+        expect(fixedContent).toContain('"京" # debug_show (c.toNat32());');
+        expect(fixedContent).toContain('"💩" # debug_show (c.toNat32());');
+        expect(fixedContent).not.toMatch(/debug_show \(Char\.toNat32/);
+        // Verify no remaining M0236 warnings.
+        const afterResult = await cli(["check", runFilePath, "--", warningFlags, "--error-format=json"], { cwd: fixDir });
+        expect(afterResult.stdout).not.toContain('"code":"M0236"');
+    });
+});

package/dist/tests/check.test.js

@@ -137,4 +137,25 @@ describe("check", () => {
         expect(result.exitCode).toBe(0);
         expect(result.stdout).toMatch(/✓ Lint fixes applied/);
     });
+    // The migrations-chain fixture has 4 migrations with check-limit=3, so the
+    // oldest is trimmed by default (staged dir + M0254 suppression). --no-check-limit
+    // must point moc at the real chain dir and drop the trimming side effects.
+    const migrationsChain = "check-stable/migrations-chain";
+    test("check-limit trims the migration chain by default", async () => {
+        const cwd = path.join(import.meta.dirname, migrationsChain);
+        const result = await cli(["check", "--verbose"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/--enhanced-migration=[^"]*\.migrations-/);
+        expect(result.stdout).toMatch(/-A=M0254/);
+    });
+    test("--no-check-limit uses the full migration chain", async () => {
+        const cwd = path.join(import.meta.dirname, migrationsChain);
+        const result = await cli(["check", "--verbose", "--no-check-limit"], {
+            cwd,
+        });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/--enhanced-migration=/);
+        expect(result.stdout).not.toMatch(/\.migrations-/);
+        expect(result.stdout).not.toMatch(/-A=M0254/);
+    });
 });

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

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