ic-mops 2.14.1 → 2.15.1

package/dist/tests/deployed.test.js

@@ -0,0 +1,173 @@
+import { describe, expect, test } from "@jest/globals";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { cli, normalizePaths, useTempFixtures } from "./helpers";
+describe("deployed", () => {
+    const makeTempFixture = useTempFixtures(path.join(import.meta.dirname, "deployed"));
+    describe("init", () => {
+        test("creates baseline .most and sets [check-stable].path", async () => {
+            const cwd = await makeTempFixture("basic");
+            const result = await cli(["deployed", "init"], { cwd });
+            expect(result.exitCode).toBe(0);
+            const baseline = path.join(cwd, "deployed", "backend.most");
+            expect(existsSync(baseline)).toBe(true);
+            expect(readFileSync(baseline, "utf-8")).toBe("// Version: 1.0.0\nactor { };\n");
+            const toml = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+            expect(toml).toMatch(/\[canisters\.backend\.check-stable\]/);
+            expect(toml).toMatch(/path\s*=\s*"deployed\/backend\.most"/);
+            expect({
+                exitCode: result.exitCode,
+                stdout: normalizePaths(result.stdout),
+                stderr: normalizePaths(result.stderr),
+            }).toMatchSnapshot();
+        });
+        test("idempotent — second run is a no-op", async () => {
+            const cwd = await makeTempFixture("basic");
+            await cli(["deployed", "init"], { cwd });
+            const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+            const result = await cli(["deployed", "init"], { cwd });
+            expect(result.exitCode).toBe(0);
+            const tomlAfter = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+            expect(tomlAfter).toBe(tomlBefore);
+        });
+        test("warns when [check-stable].path is set elsewhere", async () => {
+            const cwd = await makeTempFixture("basic");
+            const tomlPath = path.join(cwd, "mops.toml");
+            const toml = readFileSync(tomlPath, "utf-8");
+            await writeFile(tomlPath, toml +
+                '\n[canisters.backend.check-stable]\npath = "elsewhere/backend.most"\n');
+            const result = await cli(["deployed", "init"], { cwd });
+            expect(result.exitCode).toBe(0);
+            expect(result.stderr).toMatch(/check-stable\]\.path = "elsewhere\/backend\.most"/);
+            expect(result.stderr).toMatch(/does not match where `mops deployed`/);
+            expect(existsSync(path.join(cwd, "deployed", "backend.most"))).toBe(true);
+            // mops.toml should not have been rewritten
+            expect(readFileSync(tomlPath, "utf-8")).toBe(toml +
+                '\n[canisters.backend.check-stable]\npath = "elsewhere/backend.most"\n');
+        });
+        test("respects [deployed].dir", async () => {
+            const cwd = await makeTempFixture("basic");
+            const tomlPath = path.join(cwd, "mops.toml");
+            const toml = readFileSync(tomlPath, "utf-8");
+            await writeFile(tomlPath, `${toml}\n[deployed]\ndir = "snapshots"\n`);
+            const result = await cli(["deployed", "init"], { cwd });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(path.join(cwd, "snapshots", "backend.most"))).toBe(true);
+            expect(readFileSync(tomlPath, "utf-8")).toMatch(/path\s*=\s*"snapshots\/backend\.most"/);
+        });
+        test("init for shorthand canister entry promotes it to a table", async () => {
+            const cwd = await makeTempFixture("basic");
+            const tomlPath = path.join(cwd, "mops.toml");
+            await writeFile(tomlPath, '[toolchain]\nmoc = "1.5.0"\n\n[canisters]\nbackend = "main.mo"\n');
+            const result = await cli(["deployed", "init"], { cwd });
+            expect(result.exitCode).toBe(0);
+            const after = readFileSync(tomlPath, "utf-8");
+            expect(after).toMatch(/\[canisters\.backend\]/);
+            expect(after).toMatch(/main\s*=\s*"main\.mo"/);
+            expect(after).toMatch(/\[canisters\.backend\.check-stable\]/);
+            expect(after).toMatch(/path\s*=\s*"deployed\/backend\.most"/);
+        });
+        test("errors on unknown canister name", async () => {
+            const cwd = await makeTempFixture("basic");
+            const result = await cli(["deployed", "init", "ghost"], { cwd });
+            expect(result.exitCode).toBe(1);
+            expect(result.stderr).toMatch(/not found in mops\.toml/);
+        });
+        test("preserves an existing baseline file when wiring [check-stable].path", async () => {
+            const cwd = await makeTempFixture("basic");
+            const baseline = path.join(cwd, "deployed", "backend.most");
+            const customMost = "// Version: 1.0.0\nactor {\n  stable var x : Nat\n};\n";
+            // pre-create the baseline (e.g. real prod snapshot copied in by the user)
+            await mkdir(path.join(cwd, "deployed"), { recursive: true });
+            await writeFile(baseline, customMost);
+            const result = await cli(["deployed", "init"], { cwd });
+            expect(result.exitCode).toBe(0);
+            expect(readFileSync(baseline, "utf-8")).toBe(customMost);
+            expect(readFileSync(path.join(cwd, "mops.toml"), "utf-8")).toMatch(/\[canisters\.backend\.check-stable\][\s\S]*path\s*=\s*"deployed\/backend\.most"/);
+        });
+    });
+    describe("post-deploy hook", () => {
+        test("copies built .most into deployed/", async () => {
+            const cwd = await makeTempFixture("basic");
+            const buildResult = await cli(["build"], { cwd });
+            expect(buildResult.exitCode).toBe(0);
+            const result = await cli(["deployed"], { cwd });
+            expect(result.exitCode).toBe(0);
+            const built = path.join(cwd, ".mops", ".build", "backend.most");
+            const promoted = path.join(cwd, "deployed", "backend.most");
+            expect(existsSync(promoted)).toBe(true);
+            expect(readFileSync(promoted, "utf-8")).toBe(readFileSync(built, "utf-8"));
+        });
+        test("errors when source .most is missing", async () => {
+            const cwd = await makeTempFixture("basic");
+            const result = await cli(["deployed", "backend"], { cwd });
+            expect(result.exitCode).toBe(1);
+            expect(result.stderr).toMatch(/No built \.most/);
+            expect(result.stderr).toMatch(/Run `mops build backend` first/);
+        });
+        test("warns when [check-stable].path differs from <dir>/<name>.most", async () => {
+            const cwd = await makeTempFixture("basic");
+            const tomlPath = path.join(cwd, "mops.toml");
+            const toml = readFileSync(tomlPath, "utf-8");
+            await writeFile(tomlPath, toml +
+                '\n[canisters.backend.check-stable]\npath = "elsewhere/backend.most"\n');
+            const buildResult = await cli(["build"], { cwd });
+            expect(buildResult.exitCode).toBe(0);
+            const result = await cli(["deployed"], { cwd });
+            expect(result.exitCode).toBe(0);
+            expect(result.stderr).toMatch(/check-stable\]\.path = "elsewhere\/backend\.most"/);
+            expect(result.stderr).toMatch(/won't see updates from `mops deployed`/);
+        });
+        test("respects [deployed].dir from config", async () => {
+            const cwd = await makeTempFixture("basic");
+            const tomlPath = path.join(cwd, "mops.toml");
+            const toml = readFileSync(tomlPath, "utf-8");
+            await writeFile(tomlPath, `${toml}\n[deployed]\ndir = "snapshots"\n`);
+            await cli(["build"], { cwd });
+            const result = await cli(["deployed"], { cwd });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(path.join(cwd, "snapshots", "backend.most"))).toBe(true);
+            expect(existsSync(path.join(cwd, "deployed", "backend.most"))).toBe(false);
+        });
+        test("--build-dir and --dir overrides", async () => {
+            const cwd = await makeTempFixture("basic");
+            const customOut = "custom-build";
+            const customDir = "snapshots";
+            const buildResult = await cli(["build", "backend", "--output", customOut], { cwd });
+            expect(buildResult.exitCode).toBe(0);
+            const result = await cli(["deployed", "--build-dir", customOut, "--dir", customDir], { cwd });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(path.join(cwd, customDir, "backend.most"))).toBe(true);
+        });
+        test("with no canister names promotes all canisters", async () => {
+            const cwd = await makeTempFixture("multi");
+            const buildResult = await cli(["build"], { cwd });
+            expect(buildResult.exitCode).toBe(0);
+            const result = await cli(["deployed"], { cwd });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(path.join(cwd, "deployed", "foo.most"))).toBe(true);
+            expect(existsSync(path.join(cwd, "deployed", "bar.most"))).toBe(true);
+        });
+        test("named canister filters to that canister only", async () => {
+            const cwd = await makeTempFixture("multi");
+            await cli(["build"], { cwd });
+            const result = await cli(["deployed", "foo"], { cwd });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(path.join(cwd, "deployed", "foo.most"))).toBe(true);
+            expect(existsSync(path.join(cwd, "deployed", "bar.most"))).toBe(false);
+        });
+    });
+    describe("end-to-end with check-stable", () => {
+        test("init + build + deployed wires the check-stable baseline", async () => {
+            const cwd = await makeTempFixture("basic");
+            await cli(["deployed", "init"], { cwd });
+            await cli(["build"], { cwd });
+            const promoteResult = await cli(["deployed"], { cwd });
+            expect(promoteResult.exitCode).toBe(0);
+            const checkResult = await cli(["check-stable"], { cwd });
+            expect(checkResult.exitCode).toBe(0);
+            expect(checkResult.stdout).toMatch(/Stable compatibility check passed/);
+        });
+    });
+});

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

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

package/dist/tests/generate.test.js

@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import { existsSync, readFileSync } from "node:fs";
+import { cp, rm } from "node:fs/promises";
+import path from "path";
+import { cli, cliSnapshot } from "./helpers";
+const fixturesDir = path.join(import.meta.dirname, "generate");
+describe("generate candid", () => {
+    jest.setTimeout(120_000);
+    const tempDirs = [];
+    async function makeTempFixture(fixture) {
+        const src = path.join(fixturesDir, fixture);
+        const dest = path.join(fixturesDir, `_tmp_${fixture}_${Date.now()}`);
+        await cp(src, dest, { recursive: true });
+        tempDirs.push(dest);
+        return dest;
+    }
+    afterEach(async () => {
+        for (const dir of tempDirs) {
+            await rm(dir, { recursive: true, force: true });
+        }
+        tempDirs.length = 0;
+    });
+    test("default path: writes <main-dir>/<name>.did and sets [canisters.<name>].candid", async () => {
+        const cwd = await makeTempFixture("basic");
+        const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+        expect(tomlBefore).not.toMatch(/"src\/foo\.did"/);
+        await cliSnapshot(["generate", "candid", "foo"], { cwd }, 0);
+        const did = readFileSync(path.join(cwd, "src/foo.did"), "utf-8");
+        expect(did).toMatchSnapshot("src/foo.did");
+        const tomlAfter = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+        expect(tomlAfter).toMatch(/candid\s*=\s*"src\/foo\.did"/);
+    });
+    test("configured path: overwrites in place and does not touch mops.toml", async () => {
+        const cwd = await makeTempFixture("basic");
+        const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+        const didBefore = readFileSync(path.join(cwd, "candid/bar.did"), "utf-8");
+        expect(didBefore).toMatch(/Hand-curated/);
+        await cliSnapshot(["generate", "candid", "bar"], { cwd }, 0);
+        const didAfter = readFileSync(path.join(cwd, "candid/bar.did"), "utf-8");
+        expect(didAfter).not.toMatch(/Hand-curated/);
+        expect(didAfter).toMatch(/greet/);
+        expect(readFileSync(path.join(cwd, "mops.toml"), "utf-8")).toBe(tomlBefore);
+    });
+    test("no canister names: processes all canisters", async () => {
+        const cwd = await makeTempFixture("basic");
+        await cliSnapshot(["generate", "candid"], { cwd }, 0);
+        expect(existsSync(path.join(cwd, "src/foo.did"))).toBe(true);
+        const barDid = readFileSync(path.join(cwd, "candid/bar.did"), "utf-8");
+        expect(barDid).toMatch(/greet/);
+        expect(barDid).not.toMatch(/Hand-curated/);
+    });
+    test("--output writes to the given path and does not touch mops.toml", async () => {
+        const cwd = await makeTempFixture("basic");
+        const outPath = path.join(cwd, "out/custom.did");
+        const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+        const result = await cli(["generate", "candid", "foo", "-o", outPath], {
+            cwd,
+        });
+        expect(result.exitCode).toBe(0);
+        expect(existsSync(outPath)).toBe(true);
+        expect(readFileSync(outPath, "utf-8")).toMatch(/call/);
+        expect(existsSync(path.join(cwd, "src/foo.did"))).toBe(false);
+        expect(readFileSync(path.join(cwd, "mops.toml"), "utf-8")).toBe(tomlBefore);
+    });
+    test("--output rejected with multiple canisters", async () => {
+        const cwd = await makeTempFixture("basic");
+        const result = await cli(["generate", "candid", "foo", "bar", "-o", "x.did"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/single canister/i);
+    });
+    test("unknown canister name errors", async () => {
+        const cwd = await makeTempFixture("basic");
+        const result = await cli(["generate", "candid", "nope"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/not found in mops\.toml/i);
+    });
+    test("moc failure: leaves destination and mops.toml untouched", async () => {
+        const cwd = await makeTempFixture("error");
+        const tomlBefore = readFileSync(path.join(cwd, "mops.toml"), "utf-8");
+        const result = await cli(["generate", "candid", "broken"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/Failed to generate Candid/);
+        expect(existsSync(path.join(cwd, "src/broken.did"))).toBe(false);
+        expect(readFileSync(path.join(cwd, "mops.toml"), "utf-8")).toBe(tomlBefore);
+    });
+    test("rejects destination inside .mops/", async () => {
+        const cwd = await makeTempFixture("basic");
+        const result = await cli(["generate", "candid", "foo", "-o", ".mops/foo.did"], { cwd });
+        expect(result.exitCode).toBe(1);
+        expect(result.stderr).toMatch(/\.mops\//);
+        expect(result.stderr).toMatch(/Refusing/i);
+    });
+    test("creates file when [canisters.<name>].candid points to a missing path", async () => {
+        const cwd = await makeTempFixture("basic");
+        // bar's candid path points to candid/bar.did — delete it first
+        await rm(path.join(cwd, "candid/bar.did"));
+        const result = await cli(["generate", "candid", "bar"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(existsSync(path.join(cwd, "candid/bar.did"))).toBe(true);
+    });
+    test("--output collision with another canister's candid prints a warning", async () => {
+        const cwd = await makeTempFixture("basic");
+        const result = await cli(["generate", "candid", "foo", "-o", "candid/bar.did"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stderr).toMatch(/collides with \[canisters\.bar\]\.candid/);
+    });
+});

package/dist/tests/helpers.d.ts

@@ -21,3 +21,11 @@ export declare const cliSnapshot: (args: string[], options: CliOptions, exitCode
         TZ?: string;
     };
 }>>;
+/**
+ * Set up `afterEach` cleanup and return a `makeTempFixture(name)` function
+ * that copies a fixture subtree into a unique scratch dir under `fixturesDir`.
+ *
+ * Use in tests that mutate fixture files (toml edits, baseline file creation, etc.)
+ * so they don't pollute the source-controlled fixture.
+ */
+export declare function useTempFixtures(fixturesDir: string): (fixture: string) => Promise<string>;

package/dist/tests/helpers.js

@@ -1,7 +1,8 @@
-import { expect } from "@jest/globals";
+import { afterEach, expect } from "@jest/globals";
 import { execa } from "execa";
-import { dirname } from "path";
-import { fileURLToPath } from "url";
+import { cp, rm } from "node:fs/promises";
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 // When MOPS_TEST_GLOBAL is set, invoke the globally-installed `mops` binary
 // directly rather than the npm script. This exercises the real global-install
 // code path where the binary lives outside the project tree.
@@ -52,3 +53,27 @@ export const cliSnapshot = async (args, options, exitCode) => {
     }).toMatchSnapshot();
     return result;
 };
+/**
+ * Set up `afterEach` cleanup and return a `makeTempFixture(name)` function
+ * that copies a fixture subtree into a unique scratch dir under `fixturesDir`.
+ *
+ * Use in tests that mutate fixture files (toml edits, baseline file creation, etc.)
+ * so they don't pollute the source-controlled fixture.
+ */
+export function useTempFixtures(fixturesDir) {
+    const tempDirs = [];
+    afterEach(async () => {
+        for (const dir of tempDirs) {
+            await rm(dir, { recursive: true, force: true });
+        }
+        tempDirs.length = 0;
+    });
+    return async (fixture) => {
+        const src = path.join(fixturesDir, fixture);
+        const suffix = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const dest = path.join(fixturesDir, `_tmp_${fixture}_${suffix}`);
+        await cp(src, dest, { recursive: true });
+        tempDirs.push(dest);
+        return dest;
+    };
+}

package/dist/tests/migrate.test.js

@@ -1,30 +1,16 @@
-import { describe, expect, test, afterEach } from "@jest/globals";
+import { describe, expect, test } from "@jest/globals";
 import { readdirSync, readFileSync } from "node:fs";
-import { cp, rm, writeFile } from "node:fs/promises";
-import path from "path";
-import { cli, cliSnapshot, normalizePaths } from "./helpers";
+import { rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { cli, cliSnapshot, normalizePaths, useTempFixtures } from "./helpers";
 const normalizeTimestamp = (text) => text.replace(/\d{8}_\d{6}/g, "<TIMESTAMP>");
-const fixturesDir = path.join(import.meta.dirname, "migrate");
 describe("migrate", () => {
-    const tempDirs = [];
-    async function makeTempFixture(fixture) {
-        const src = path.join(fixturesDir, fixture);
-        const dest = path.join(fixturesDir, `_tmp_${fixture}_${Date.now()}`);
-        await cp(src, dest, { recursive: true });
-        tempDirs.push(dest);
-        return dest;
-    }
+    const makeTempFixture = useTempFixtures(path.join(import.meta.dirname, "migrate"));
     async function patchMigrations(cwd, extra) {
         const tomlPath = path.join(cwd, "mops.toml");
         const toml = readFileSync(tomlPath, "utf-8");
         await writeFile(tomlPath, toml.replace('next = "next-migration"', `next = "next-migration"\n${extra}`));
     }
-    afterEach(async () => {
-        for (const dir of tempDirs) {
-            await rm(dir, { recursive: true, force: true });
-        }
-        tempDirs.length = 0;
-    });
     describe("migrate new", () => {
         test("creates a migration file with timestamp and template", async () => {
             const cwd = await makeTempFixture("basic");

package/dist/types.d.ts

@@ -27,6 +27,9 @@ export type Config = {
         outputDir?: string;
         args?: string[];
     };
+    deployed?: {
+        dir?: string;
+    };
     lint?: {
         args?: string[];
         rules?: string[];

package/helpers/autofix-motoko.ts

@@ -1,13 +1,14 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
+import chalk from "chalk";
 import { execa } from "execa";
-import {
-  TextDocument,
-  type TextEdit,
-} from "vscode-languageserver-textdocument";
+import { TextDocument } from "vscode-languageserver-textdocument";
 
 interface MocSpan {
   file: string;
+  // Optional: older moc versions don't emit byte offsets.
+  byte_start?: number | null;
+  byte_end?: number | null;
   line_start: number;
   column_start: number;
   line_end: number;
@@ -43,9 +44,14 @@ export function parseDiagnostics(stdout: string | undefined): MocDiagnostic[] {
     .filter((d) => d !== null);
 }
 
+interface Edit {
+  span: MocSpan;
+  newText: string;
+}
+
 interface DiagnosticFix {
   code: string;
-  edits: TextEdit[];
+  edits: Edit[];
 }
 
 function extractDiagnosticFixes(
@@ -54,30 +60,19 @@ function extractDiagnosticFixes(
   const result = new Map<string, DiagnosticFix[]>();
 
   for (const diag of diagnostics) {
-    const editsByFile = new Map<string, TextEdit[]>();
+    const editsByFile = new Map<string, Edit[]>();
 
     for (const span of diag.spans) {
       if (
-        span.suggestion_applicability === "MachineApplicable" &&
-        span.suggested_replacement !== null
+        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);
+        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) {
@@ -90,19 +85,6 @@ function extractDiagnosticFixes(
   return result;
 }
 
-type Range = TextEdit["range"];
-
-function normalizeRange(range: Range): 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;
-}
-
 interface OffsetEdit {
   start: number;
   end: number;
@@ -110,27 +92,53 @@ interface OffsetEdit {
 }
 
 /**
- * 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: TextDocument,
+  content: string,
   fixes: DiagnosticFix[],
 ): { text: string; appliedCodes: string[] } {
+  let buf: Buffer | null = null;
+  const byteToOffset = (byteOffset: number): number => {
+    buf ??= Buffer.from(content, "utf8");
+    return buf.subarray(0, byteOffset).toString("utf8").length;
+  };
+  let doc: TextDocument | null = null;
+
+  const toOffsetEdit = ({ span, newText }: Edit): OffsetEdit => {
+    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: OffsetEdit[] = [];
   const appliedCodes: string[] = [];
 
   for (const fix of fixes) {
-    const offsets: OffsetEdit[] = 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),
@@ -145,7 +153,6 @@ function applyDiagnosticFixes(
 
   acceptedEdits.sort((a, b) => a.start - b.start);
 
-  const text = doc.getText();
   const spans: string[] = [];
   let lastOffset = 0;
 
@@ -154,7 +161,7 @@ function applyDiagnosticFixes(
       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);
@@ -162,7 +169,7 @@ function applyDiagnosticFixes(
     lastOffset = edit.end;
   }
 
-  spans.push(text.substring(lastOffset));
+  spans.push(content.substring(lastOffset));
   return { text: spans.join(""), appliedCodes };
 }
 
@@ -180,22 +187,26 @@ export async function autofixMotoko(
   mocArgs: string[],
 ): Promise<AutofixResult | null> {
   const fixedFilesCodes = new Map<string, string[]>();
+  // Frozen migration files are often chmod'd read-only; warn once and skip
+  // them rather than aborting the whole run on EACCES/EPERM.
+  const readOnlySkipped = new Set<string>();
 
   for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
     const fixesByFile = new Map<string, DiagnosticFix[]>();
 
-    // Single invocation: moc dedups shared imports across all files.
-    const result = await execa(
-      mocPath,
-      [...files, ...mocArgs, "--error-format=json"],
-      { stdio: "pipe", reject: false },
-    );
-
-    const diagnostics = parseDiagnostics(result.stdout);
-    for (const [targetFile, fixes] of extractDiagnosticFixes(diagnostics)) {
-      const existing = fixesByFile.get(targetFile) ?? [];
-      existing.push(...fixes);
-      fixesByFile.set(targetFile, existing);
+    for (const file of files) {
+      const result = await execa(
+        mocPath,
+        [file, ...mocArgs, "--error-format=json"],
+        { stdio: "pipe", reject: false },
+      );
+
+      const diagnostics = parseDiagnostics(result.stdout);
+      for (const [targetFile, fixes] of extractDiagnosticFixes(diagnostics)) {
+        const existing = fixesByFile.get(targetFile) ?? [];
+        existing.push(...fixes);
+        fixesByFile.set(targetFile, existing);
+      }
     }
 
     if (fixesByFile.size === 0) {
@@ -205,15 +216,34 @@ export async function autofixMotoko(
     let progress = false;
 
     for (const [file, fixes] of fixesByFile) {
+      if (readOnlySkipped.has(file)) {
+        continue;
+      }
+
       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;
       }
 
-      await writeFile(file, result, "utf-8");
+      try {
+        await writeFile(file, result, "utf-8");
+      } catch (err: any) {
+        if (err?.code === "EACCES" || err?.code === "EPERM") {
+          readOnlySkipped.add(file);
+          console.warn(
+            chalk.yellow(
+              `Skipped read-only file ${relative(process.cwd(), file)} (${appliedCodes.length} fix(es) not applied)`,
+            ),
+          );
+          continue;
+        }
+        throw err;
+      }
       progress = true;
 
       const existing = fixedFilesCodes.get(file) ?? [];