pushwork 2.0.0-a.sub.0 → 2.0.0-preview

package/test/unit/snapshot.test.ts

@@ -1,404 +0,0 @@
-import * as path from "path";
-import * as tmp from "tmp";
-import { SnapshotManager } from "../../src/core/snapshot";
-import { SnapshotFileEntry, SnapshotDirectoryEntry } from "../../src/types";
-import { UrlHeads } from "@automerge/automerge-repo";
-
-describe("SnapshotManager", () => {
-  let tmpDir: string;
-  let cleanup: () => void;
-  let snapshotManager: SnapshotManager;
-
-  beforeEach(() => {
-    const tmpObj = tmp.dirSync({ unsafeCleanup: true });
-    tmpDir = tmpObj.name;
-    cleanup = tmpObj.removeCallback;
-    snapshotManager = new SnapshotManager(tmpDir);
-  });
-
-  afterEach(() => {
-    cleanup();
-  });
-
-  describe("exists", () => {
-    it("should return false when no snapshot exists", async () => {
-      expect(await snapshotManager.exists()).toBe(false);
-    });
-
-    it("should return true when snapshot exists", async () => {
-      const snapshot = snapshotManager.createEmpty();
-      await snapshotManager.save(snapshot);
-
-      expect(await snapshotManager.exists()).toBe(true);
-    });
-  });
-
-  describe("createEmpty", () => {
-    it("should create an empty snapshot", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      expect(snapshot.rootPath).toBe(tmpDir);
-      expect(snapshot.timestamp).toBeGreaterThan(0);
-      expect(snapshot.files.size).toBe(0);
-      expect(snapshot.directories.size).toBe(0);
-    });
-  });
-
-  describe("save and load", () => {
-    it("should save and load empty snapshot", async () => {
-      const originalSnapshot = snapshotManager.createEmpty();
-
-      await snapshotManager.save(originalSnapshot);
-      const loadedSnapshot = await snapshotManager.load();
-
-      expect(loadedSnapshot).not.toBeNull();
-      expect(loadedSnapshot!.rootPath).toBe(originalSnapshot.rootPath);
-      expect(loadedSnapshot!.timestamp).toBe(originalSnapshot.timestamp);
-      expect(loadedSnapshot!.files.size).toBe(0);
-      expect(loadedSnapshot!.directories.size).toBe(0);
-    });
-
-    it("should save and load snapshot with files", async () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      const fileEntry: SnapshotFileEntry = {
-        path: path.join(tmpDir, "test.txt"),
-        url: "automerge:test-url" as any,
-        head: ["test-head"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      };
-
-      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry);
-
-      await snapshotManager.save(snapshot);
-      const loadedSnapshot = await snapshotManager.load();
-
-      expect(loadedSnapshot).not.toBeNull();
-      expect(loadedSnapshot!.files.size).toBe(1);
-      expect(loadedSnapshot!.files.get("test.txt")).toEqual(fileEntry);
-    });
-
-    it("should save and load snapshot with directories", async () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      const dirEntry: SnapshotDirectoryEntry = {
-        path: path.join(tmpDir, "subdir"),
-        url: "automerge:dir-url" as any,
-        head: ["dir-head"] as UrlHeads,
-        entries: ["file1.txt", "file2.txt"],
-      };
-
-      snapshotManager.updateDirectoryEntry(snapshot, "subdir", dirEntry);
-
-      await snapshotManager.save(snapshot);
-      const loadedSnapshot = await snapshotManager.load();
-
-      expect(loadedSnapshot).not.toBeNull();
-      expect(loadedSnapshot!.directories.size).toBe(1);
-      expect(loadedSnapshot!.directories.get("subdir")).toEqual(dirEntry);
-    });
-
-    it("should return null when loading non-existent snapshot", async () => {
-      const loadedSnapshot = await snapshotManager.load();
-      expect(loadedSnapshot).toBeNull();
-    });
-  });
-
-  describe("updateFileEntry", () => {
-    it("should add new file entry", () => {
-      const snapshot = snapshotManager.createEmpty();
-      const originalTimestamp = snapshot.timestamp;
-
-      const fileEntry: SnapshotFileEntry = {
-        path: "/test/path/test.txt",
-        url: "automerge:test-url" as any,
-        head: ["test-head"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      };
-
-      // Add small delay to ensure timestamp changes
-      const startTime = Date.now();
-      while (Date.now() === startTime) {
-        // Wait for at least 1ms
-      }
-
-      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry);
-
-      expect(snapshot.files.get("test.txt")).toEqual(fileEntry);
-      expect(snapshot.timestamp).toBeGreaterThan(originalTimestamp);
-    });
-
-    it("should update existing file entry", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      const fileEntry1: SnapshotFileEntry = {
-        path: path.join(tmpDir, "test.txt"),
-        url: "automerge:test-url" as any,
-        head: ["old-head"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      };
-
-      const fileEntry2: SnapshotFileEntry = {
-        path: path.join(tmpDir, "test.txt"),
-        url: "automerge:test-url" as any,
-        head: ["new-head"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      };
-
-      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry1);
-      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry2);
-
-      expect(snapshot.files.get("test.txt")).toEqual(fileEntry2);
-      expect(snapshot.files.size).toBe(1);
-    });
-  });
-
-  describe("removeFileEntry", () => {
-    it("should remove file entry", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      const fileEntry: SnapshotFileEntry = {
-        path: path.join(tmpDir, "test.txt"),
-        url: "automerge:test-url" as any,
-        head: ["test-head"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      };
-
-      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry);
-      expect(snapshot.files.size).toBe(1);
-
-      snapshotManager.removeFileEntry(snapshot, "test.txt");
-      expect(snapshot.files.size).toBe(0);
-      expect(snapshot.files.get("test.txt")).toBeUndefined();
-    });
-
-    it("should not fail when removing non-existent file", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      snapshotManager.removeFileEntry(snapshot, "nonexistent.txt");
-      expect(snapshot.files.size).toBe(0);
-    });
-  });
-
-  describe("getFilePaths and getDirectoryPaths", () => {
-    it("should return all file paths", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      snapshotManager.updateFileEntry(snapshot, "file1.txt", {
-        path: path.join(tmpDir, "file1.txt"),
-        url: "automerge:url1" as any,
-        head: ["head1"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      });
-
-      snapshotManager.updateFileEntry(snapshot, "file2.txt", {
-        path: path.join(tmpDir, "file2.txt"),
-        url: "automerge:url2" as any,
-        head: ["head2"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      });
-
-      const filePaths = snapshotManager.getFilePaths(snapshot);
-      expect(filePaths.sort()).toEqual(["file1.txt", "file2.txt"]);
-    });
-
-    it("should return all directory paths", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      snapshotManager.updateDirectoryEntry(snapshot, "dir1", {
-        path: path.join(tmpDir, "dir1"),
-        url: "automerge:url1" as any,
-        head: ["head1"] as UrlHeads,
-        entries: [],
-      });
-
-      snapshotManager.updateDirectoryEntry(snapshot, "dir2", {
-        path: path.join(tmpDir, "dir2"),
-        url: "automerge:url2" as any,
-        head: ["head2"] as UrlHeads,
-        entries: [],
-      });
-
-      const dirPaths = snapshotManager.getDirectoryPaths(snapshot);
-      expect(dirPaths.sort()).toEqual(["dir1", "dir2"]);
-    });
-  });
-
-  describe("isTracked", () => {
-    it("should return true for tracked files", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      snapshotManager.updateFileEntry(snapshot, "test.txt", {
-        path: path.join(tmpDir, "test.txt"),
-        url: "automerge:url" as any,
-        head: ["head"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      });
-
-      expect(snapshotManager.isTracked(snapshot, "test.txt")).toBe(true);
-      expect(snapshotManager.isTracked(snapshot, "other.txt")).toBe(false);
-    });
-
-    it("should return true for tracked directories", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      snapshotManager.updateDirectoryEntry(snapshot, "subdir", {
-        path: path.join(tmpDir, "subdir"),
-        url: "automerge:url" as any,
-        head: ["head"] as UrlHeads,
-        entries: [],
-      });
-
-      expect(snapshotManager.isTracked(snapshot, "subdir")).toBe(true);
-      expect(snapshotManager.isTracked(snapshot, "other")).toBe(false);
-    });
-  });
-
-  describe("getStats", () => {
-    it("should return correct statistics", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      snapshotManager.updateFileEntry(snapshot, "file1.txt", {
-        path: path.join(tmpDir, "file1.txt"),
-        url: "automerge:url1" as any,
-        head: ["head1"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      });
-
-      snapshotManager.updateDirectoryEntry(snapshot, "dir1", {
-        path: path.join(tmpDir, "dir1"),
-        url: "automerge:url2" as any,
-        head: ["head2"] as UrlHeads,
-        entries: [],
-      });
-
-      const stats = snapshotManager.getStats(snapshot);
-
-      expect(stats.files).toBe(1);
-      expect(stats.directories).toBe(1);
-      expect(stats.timestamp).toBeInstanceOf(Date);
-      expect(stats.timestamp.getTime()).toBe(snapshot.timestamp);
-    });
-  });
-
-  describe("validate", () => {
-    it("should validate correct snapshot", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      const validation = snapshotManager.validate(snapshot);
-
-      expect(validation.valid).toBe(true);
-      expect(validation.errors).toHaveLength(0);
-    });
-
-    it("should detect invalid timestamp", () => {
-      const snapshot = snapshotManager.createEmpty();
-      snapshot.timestamp = 0;
-
-      const validation = snapshotManager.validate(snapshot);
-
-      expect(validation.valid).toBe(false);
-      expect(validation.errors).toContain("Invalid timestamp");
-    });
-
-    it("should detect missing root path", () => {
-      const snapshot = snapshotManager.createEmpty();
-      snapshot.rootPath = "";
-
-      const validation = snapshotManager.validate(snapshot);
-
-      expect(validation.valid).toBe(false);
-      expect(validation.errors).toContain("Missing root path");
-    });
-
-    it("should detect path conflicts", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      snapshotManager.updateFileEntry(snapshot, "conflict", {
-        path: path.join(tmpDir, "conflict"),
-        url: "automerge:url1" as any,
-        head: ["head1"] as UrlHeads,
-        extension: "",
-        mimeType: "text/plain",
-      });
-
-      snapshotManager.updateDirectoryEntry(snapshot, "conflict", {
-        path: path.join(tmpDir, "conflict"),
-        url: "automerge:url2" as any,
-        head: ["head2"] as UrlHeads,
-        entries: [],
-      });
-
-      const validation = snapshotManager.validate(snapshot);
-
-      expect(validation.valid).toBe(false);
-      expect(validation.errors).toContain(
-        "Path conflict: conflict exists as both file and directory"
-      );
-    });
-  });
-
-  describe("clone", () => {
-    it("should create independent copy of snapshot", () => {
-      const originalSnapshot = snapshotManager.createEmpty();
-
-      snapshotManager.updateFileEntry(originalSnapshot, "test.txt", {
-        path: path.join(tmpDir, "test.txt"),
-        url: "automerge:url" as any,
-        head: ["head"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      });
-
-      const clonedSnapshot = snapshotManager.clone(originalSnapshot);
-
-      // Modify clone
-      snapshotManager.removeFileEntry(clonedSnapshot, "test.txt");
-
-      // Original should be unchanged
-      expect(originalSnapshot.files.size).toBe(1);
-      expect(clonedSnapshot.files.size).toBe(0);
-    });
-  });
-
-  describe("clear", () => {
-    it("should clear all data from snapshot", async () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      snapshotManager.updateFileEntry(snapshot, "test.txt", {
-        path: path.join(tmpDir, "test.txt"),
-        url: "automerge:url" as any,
-        head: ["head"] as UrlHeads,
-        extension: "txt",
-        mimeType: "text/plain",
-      });
-
-      snapshotManager.updateDirectoryEntry(snapshot, "subdir", {
-        path: path.join(tmpDir, "subdir"),
-        url: "automerge:url" as any,
-        head: ["head"] as UrlHeads,
-        entries: [],
-      });
-
-      const originalTimestamp = snapshot.timestamp;
-
-      // Add small delay to ensure timestamp difference
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      snapshotManager.clear(snapshot);
-
-      expect(snapshot.files.size).toBe(0);
-      expect(snapshot.directories.size).toBe(0);
-      expect(snapshot.timestamp).toBeGreaterThan(originalTimestamp);
-    });
-  });
-});

package/test/unit/sync-convergence.test.ts

@@ -1,298 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { tmpdir } from "os";
-import { SnapshotManager } from "../../src/core/snapshot";
-import { ChangeDetector } from "../../src/core/change-detection";
-import { MoveDetector } from "../../src/core/move-detection";
-import { writeFileContent, removePath, pathExists } from "../../src/utils";
-
-describe("Sync Convergence Issues", () => {
-  let testDir: string;
-  let snapshotManager: SnapshotManager;
-
-  beforeEach(async () => {
-    testDir = await fs.mkdtemp(path.join(tmpdir(), "sync-convergence-test-"));
-    snapshotManager = new SnapshotManager(testDir);
-
-    // Create mock repo for change detector - we'll focus on change detection logic
-    const mockRepo = {} as any;
-    new ChangeDetector(mockRepo, testDir, []);
-    new MoveDetector();
-  });
-
-  afterEach(async () => {
-    await fs.rm(testDir, { recursive: true, force: true });
-  });
-
-  describe("Change Detection Patterns", () => {
-    it("should verify that convergence issues are fixed", async () => {
-      // === SETUP PHASE ===
-
-      // Create initial file structure similar to Vite build output
-      const initialFiles = [
-        {
-          name: "assets/tool-DhQI94EZ.js",
-          content: "// Initial tool bundle\nexport const tool = 'v1';",
-        },
-        {
-          name: "assets/index-BKR4T14z.js",
-          content: "// Index bundle\nexport const app = 'main';",
-        },
-        {
-          name: "index.js",
-          content: "// Main entry\nimport './assets/tool-DhQI94EZ.js';",
-        },
-      ];
-
-      for (const file of initialFiles) {
-        const filePath = path.join(testDir, file.name);
-        await fs.mkdir(path.dirname(filePath), { recursive: true });
-        await writeFileContent(filePath, file.content);
-      }
-
-      // Create initial snapshot representing the "synced" state
-      const snapshot = snapshotManager.createEmpty();
-
-      // Simulate files being tracked in snapshot with mock URLs and heads
-      for (const file of initialFiles) {
-        snapshotManager.updateFileEntry(snapshot, file.name, {
-          path: path.join(testDir, file.name),
-          url: `automerge:mock-${file.name.replace(/[\/\.]/g, "-")}` as any,
-          head: [`mock-head-${file.name}`] as any,
-          extension: path.extname(file.name).slice(1) || "js",
-          mimeType: "text/javascript",
-        });
-      }
-
-      // === SIMULATE BUILD PROCESS ===
-
-      // Delete old file and create new one (simulating Vite's content-based naming)
-      await removePath(path.join(testDir, "assets/tool-DhQI94EZ.js"));
-
-      const newToolFile = "assets/tool-CR5n6i_K.js";
-      await writeFileContent(
-        path.join(testDir, newToolFile),
-        "// New tool bundle with different hash\nexport const tool = 'v2';"
-      );
-
-      // Update the main file to reference the new bundle
-      await writeFileContent(
-        path.join(testDir, "index.js"),
-        "// Main entry\nimport './assets/tool-CR5n6i_K.js';"
-      );
-
-      // This is where we would normally detect changes, but we'll simulate the issue
-      // by showing what the change detector would find vs what should happen
-
-      // Simulate what change detection finds
-      const deletedFile = "assets/tool-DhQI94EZ.js";
-      const createdFile = "assets/tool-CR5n6i_K.js";
-
-      // Simulate multiple "sync runs" by checking filesystem state
-      let syncRun = 1;
-      let changesRemaining = true;
-
-      while (changesRemaining && syncRun <= 3) {
-        // Check what should be synced
-        const fileExists = await pathExists(path.join(testDir, deletedFile));
-        const isTrackedInSnapshot = snapshot.files.has(deletedFile);
-
-        if (!fileExists && isTrackedInSnapshot) {
-          // In a real scenario with the bug, this deletion might not complete properly
-          // due to stale directory heads, causing it to remain in the directory document
-
-          // Simulate partial success - remove from snapshot but directory doc might still reference it
-          snapshotManager.removeFileEntry(snapshot, deletedFile);
-        }
-
-        const newFileExists = await pathExists(path.join(testDir, createdFile));
-        const newFileTracked = snapshot.files.has(createdFile);
-
-        if (newFileExists && !newFileTracked) {
-          // Add new file to snapshot
-          snapshotManager.updateFileEntry(snapshot, createdFile, {
-            path: path.join(testDir, createdFile),
-            url: `automerge:mock-${createdFile.replace(/[\/\.]/g, "-")}` as any,
-            head: [`mock-head-${createdFile}`] as any,
-            extension: "js",
-            mimeType: "text/javascript",
-          });
-        }
-
-        // Check if we still have work to do
-        // With the fix: Directory heads are properly updated, so convergence happens in 1 run
-        if (syncRun === 1) {
-          changesRemaining = false; // Fixed behavior: converge immediately
-        } else {
-          // This shouldn't happen with the fix
-          changesRemaining = false;
-        }
-
-        syncRun++;
-      }
-
-      expect(syncRun - 1).toBe(1);
-
-      // Verify final filesystem state is correct regardless of sync issues
-      expect(
-        await pathExists(path.join(testDir, "assets/tool-DhQI94EZ.js"))
-      ).toBe(false);
-      expect(
-        await pathExists(path.join(testDir, "assets/tool-CR5n6i_K.js"))
-      ).toBe(true);
-      expect(await pathExists(path.join(testDir, "index.js"))).toBe(true);
-
-      // Verify snapshot state
-      expect(snapshot.files.has("assets/tool-DhQI94EZ.js")).toBe(false);
-      expect(snapshot.files.has("assets/tool-CR5n6i_K.js")).toBe(true);
-
-      expect(syncRun - 1).toBe(1); // Fixed behavior: exactly 1 run
-    });
-
-    it("should demonstrate snapshot head tracking concepts", async () => {
-      // Create a simple file structure
-      await fs.mkdir(path.join(testDir, "subdir"), { recursive: true });
-      await writeFileContent(
-        path.join(testDir, "subdir/test.js"),
-        "console.log('test');"
-      );
-
-      // Create snapshot
-      const snapshot = snapshotManager.createEmpty();
-
-      // Add directory entry with initial "heads"
-      snapshotManager.updateDirectoryEntry(snapshot, "subdir", {
-        path: path.join(testDir, "subdir"),
-        url: "automerge:mock-subdir" as any,
-        head: ["initial-head"] as any, // This represents the initial state
-        entries: [],
-      });
-
-      // Add file entry
-      snapshotManager.updateFileEntry(snapshot, "subdir/test.js", {
-        path: path.join(testDir, "subdir/test.js"),
-        url: "automerge:mock-file" as any,
-        head: ["file-head"] as any,
-        extension: "js",
-        mimeType: "text/javascript",
-      });
-
-      // === SIMULATE THE HEAD TRACKING ISSUE ===
-
-      // Delete the file locally
-      await removePath(path.join(testDir, "subdir/test.js"));
-
-      // In a real sync scenario, we would:
-      // 1. Detect the file deletion
-      // 2. Remove file from directory document using current heads
-      // 3. Update snapshot with new heads
-
-      // THE BUG: Step 3 might not happen properly, causing stale heads
-
-      // Simulate what should happen (correct behavior)
-      snapshotManager.removeFileEntry(snapshot, "subdir/test.js");
-
-      // Simulate directory heads advancing after modification
-      const directoryEntry = snapshot.directories.get("subdir");
-      if (directoryEntry) {
-        // In real sync, heads would advance: ["initial-head"] -> ["new-head-after-deletion"]
-        const newHeads = ["new-head-after-deletion"];
-
-        directoryEntry.head = newHeads as any;
-      }
-
-      // Verify the concept
-      const fileStillExists = await pathExists(
-        path.join(testDir, "subdir/test.js")
-      );
-      const fileStillTracked = snapshot.files.has("subdir/test.js");
-
-      expect(fileStillExists).toBe(false);
-      expect(fileStillTracked).toBe(false);
-    });
-  });
-
-  describe("Move Detection Interaction", () => {
-    it("should show how move detection affects convergence behavior", async () => {
-      // Create initial file
-      await writeFileContent(
-        path.join(testDir, "original.js"),
-        "console.log('original');"
-      );
-
-      // Create snapshot tracking the original file
-      const snapshot = snapshotManager.createEmpty();
-      snapshotManager.updateFileEntry(snapshot, "original.js", {
-        path: path.join(testDir, "original.js"),
-        url: "automerge:original" as any,
-        head: ["original-head"] as any,
-        extension: "js",
-        mimeType: "text/javascript",
-      });
-
-      // === SIMULATE RENAME WITH LOW SIMILARITY ===
-
-      // Delete original and create "renamed" file with different content (low similarity)
-      await removePath(path.join(testDir, "original.js"));
-      await writeFileContent(
-        path.join(testDir, "renamed.js"),
-        "// Completely different content\nconst newFeature = () => { return 'different'; };"
-      );
-
-      // Since move detection doesn't apply, we process as delete + create
-      // This should ALWAYS converge in exactly 1 sync run, but the bug causes more
-
-      let convergenceRuns = 0;
-      let hasChanges = true;
-
-      while (hasChanges && convergenceRuns < 3) {
-        convergenceRuns++;
-
-        // Check for deletion
-        const originalExists = await pathExists(
-          path.join(testDir, "original.js")
-        );
-        const originalTracked = snapshot.files.has("original.js");
-
-        if (!originalExists && originalTracked) {
-          snapshotManager.removeFileEntry(snapshot, "original.js");
-        }
-
-        // Check for addition
-        const newExists = await pathExists(path.join(testDir, "renamed.js"));
-        const newTracked = snapshot.files.has("renamed.js");
-
-        if (newExists && !newTracked) {
-          snapshotManager.updateFileEntry(snapshot, "renamed.js", {
-            path: path.join(testDir, "renamed.js"),
-            url: "automerge:renamed" as any,
-            head: ["renamed-head"] as any,
-            extension: "js",
-            mimeType: "text/javascript",
-          });
-        }
-
-        // Determine if more runs needed
-        // With the fix: Directory heads are properly updated, so convergence happens in 1 run
-        if (convergenceRuns === 1) {
-          hasChanges = false; // Fixed: converge immediately
-        } else {
-          // This shouldn't happen with the fix
-          hasChanges = false;
-          console.log(
-            "🚨 UNEXPECTED: Required multiple runs - fix may not be working"
-          );
-        }
-      }
-
-      // Verify final state
-      expect(await pathExists(path.join(testDir, "original.js"))).toBe(false);
-      expect(await pathExists(path.join(testDir, "renamed.js"))).toBe(true);
-      expect(snapshot.files.has("original.js")).toBe(false);
-      expect(snapshot.files.has("renamed.js")).toBe(true);
-
-      // Test assertion: Verify convergence in exactly 1 run
-      expect(convergenceRuns).toBe(1);
-    });
-  });
-});