chad-code 1.3.1 → 1.3.3

package/test/snapshot/snapshot.test.ts

@@ -1,939 +0,0 @@
-import { test, expect } from "bun:test"
-import { $ } from "bun"
-import { Snapshot } from "../../src/snapshot"
-import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
-
-async function bootstrap() {
-  return tmpdir({
-    git: true,
-    init: async (dir) => {
-      const unique = Math.random().toString(36).slice(2)
-      const aContent = `A${unique}`
-      const bContent = `B${unique}`
-      await Bun.write(`${dir}/a.txt`, aContent)
-      await Bun.write(`${dir}/b.txt`, bContent)
-      await $`git add .`.cwd(dir).quiet()
-      await $`git commit --no-gpg-sign -m init`.cwd(dir).quiet()
-      return {
-        aContent,
-        bContent,
-      }
-    },
-  })
-}
-
-test("tracks deleted files correctly", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await $`rm ${tmp.path}/a.txt`.quiet()
-
-      expect((await Snapshot.patch(before!)).files).toContain(`${tmp.path}/a.txt`)
-    },
-  })
-})
-
-test("revert should remove new files", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/new.txt`, "NEW")
-
-      await Snapshot.revert([await Snapshot.patch(before!)])
-
-      expect(await Bun.file(`${tmp.path}/new.txt`).exists()).toBe(false)
-    },
-  })
-})
-
-test("revert in subdirectory", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await $`mkdir -p ${tmp.path}/sub`.quiet()
-      await Bun.write(`${tmp.path}/sub/file.txt`, "SUB")
-
-      await Snapshot.revert([await Snapshot.patch(before!)])
-
-      expect(await Bun.file(`${tmp.path}/sub/file.txt`).exists()).toBe(false)
-      // Note: revert currently only removes files, not directories
-      // The empty subdirectory will remain
-    },
-  })
-})
-
-test("multiple file operations", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await $`rm ${tmp.path}/a.txt`.quiet()
-      await Bun.write(`${tmp.path}/c.txt`, "C")
-      await $`mkdir -p ${tmp.path}/dir`.quiet()
-      await Bun.write(`${tmp.path}/dir/d.txt`, "D")
-      await Bun.write(`${tmp.path}/b.txt`, "MODIFIED")
-
-      await Snapshot.revert([await Snapshot.patch(before!)])
-
-      expect(await Bun.file(`${tmp.path}/a.txt`).text()).toBe(tmp.extra.aContent)
-      expect(await Bun.file(`${tmp.path}/c.txt`).exists()).toBe(false)
-      // Note: revert currently only removes files, not directories
-      // The empty directory will remain
-      expect(await Bun.file(`${tmp.path}/b.txt`).text()).toBe(tmp.extra.bContent)
-    },
-  })
-})
-
-test("empty directory handling", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await $`mkdir ${tmp.path}/empty`.quiet()
-
-      expect((await Snapshot.patch(before!)).files.length).toBe(0)
-    },
-  })
-})
-
-test("binary file handling", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/image.png`, new Uint8Array([0x89, 0x50, 0x4e, 0x47]))
-
-      const patch = await Snapshot.patch(before!)
-      expect(patch.files).toContain(`${tmp.path}/image.png`)
-
-      await Snapshot.revert([patch])
-      expect(await Bun.file(`${tmp.path}/image.png`).exists()).toBe(false)
-    },
-  })
-})
-
-test("symlink handling", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await $`ln -s ${tmp.path}/a.txt ${tmp.path}/link.txt`.quiet()
-
-      expect((await Snapshot.patch(before!)).files).toContain(`${tmp.path}/link.txt`)
-    },
-  })
-})
-
-test("large file handling", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/large.txt`, "x".repeat(1024 * 1024))
-
-      expect((await Snapshot.patch(before!)).files).toContain(`${tmp.path}/large.txt`)
-    },
-  })
-})
-
-test("nested directory revert", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await $`mkdir -p ${tmp.path}/level1/level2/level3`.quiet()
-      await Bun.write(`${tmp.path}/level1/level2/level3/deep.txt`, "DEEP")
-
-      await Snapshot.revert([await Snapshot.patch(before!)])
-
-      expect(await Bun.file(`${tmp.path}/level1/level2/level3/deep.txt`).exists()).toBe(false)
-    },
-  })
-})
-
-test("special characters in filenames", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/file with spaces.txt`, "SPACES")
-      await Bun.write(`${tmp.path}/file-with-dashes.txt`, "DASHES")
-      await Bun.write(`${tmp.path}/file_with_underscores.txt`, "UNDERSCORES")
-
-      const files = (await Snapshot.patch(before!)).files
-      expect(files).toContain(`${tmp.path}/file with spaces.txt`)
-      expect(files).toContain(`${tmp.path}/file-with-dashes.txt`)
-      expect(files).toContain(`${tmp.path}/file_with_underscores.txt`)
-    },
-  })
-})
-
-test("revert with empty patches", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      // Should not crash with empty patches
-      expect(Snapshot.revert([])).resolves.toBeUndefined()
-
-      // Should not crash with patches that have empty file lists
-      expect(Snapshot.revert([{ hash: "dummy", files: [] }])).resolves.toBeUndefined()
-    },
-  })
-})
-
-test("patch with invalid hash", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Create a change
-      await Bun.write(`${tmp.path}/test.txt`, "TEST")
-
-      // Try to patch with invalid hash - should handle gracefully
-      const patch = await Snapshot.patch("invalid-hash-12345")
-      expect(patch.files).toEqual([])
-      expect(patch.hash).toBe("invalid-hash-12345")
-    },
-  })
-})
-
-test("revert non-existent file", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Try to revert a file that doesn't exist in the snapshot
-      // This should not crash
-      expect(
-        Snapshot.revert([
-          {
-            hash: before!,
-            files: [`${tmp.path}/nonexistent.txt`],
-          },
-        ]),
-      ).resolves.toBeUndefined()
-    },
-  })
-})
-
-test("unicode filenames", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      const unicodeFiles = [
-        `${tmp.path}/文件.txt`,
-        `${tmp.path}/🚀rocket.txt`,
-        `${tmp.path}/café.txt`,
-        `${tmp.path}/файл.txt`,
-      ]
-
-      for (const file of unicodeFiles) {
-        await Bun.write(file, "unicode content")
-      }
-
-      const patch = await Snapshot.patch(before!)
-      // Note: git escapes unicode characters by default, so we just check that files are detected
-      // The actual filenames will be escaped like "caf\303\251.txt" but functionality works
-      expect(patch.files.length).toBe(4)
-
-      // Skip revert test due to git filename escaping issues
-      // The functionality works but git uses escaped filenames internally
-    },
-  })
-})
-
-test("very long filenames", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      const longName = "a".repeat(200) + ".txt"
-      const longFile = `${tmp.path}/${longName}`
-
-      await Bun.write(longFile, "long filename content")
-
-      const patch = await Snapshot.patch(before!)
-      expect(patch.files).toContain(longFile)
-
-      await Snapshot.revert([patch])
-      expect(await Bun.file(longFile).exists()).toBe(false)
-    },
-  })
-})
-
-test("hidden files", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/.hidden`, "hidden content")
-      await Bun.write(`${tmp.path}/.gitignore`, "*.log")
-      await Bun.write(`${tmp.path}/.config`, "config content")
-
-      const patch = await Snapshot.patch(before!)
-      expect(patch.files).toContain(`${tmp.path}/.hidden`)
-      expect(patch.files).toContain(`${tmp.path}/.gitignore`)
-      expect(patch.files).toContain(`${tmp.path}/.config`)
-    },
-  })
-})
-
-test("nested symlinks", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await $`mkdir -p ${tmp.path}/sub/dir`.quiet()
-      await Bun.write(`${tmp.path}/sub/dir/target.txt`, "target content")
-      await $`ln -s ${tmp.path}/sub/dir/target.txt ${tmp.path}/sub/dir/link.txt`.quiet()
-      await $`ln -s ${tmp.path}/sub ${tmp.path}/sub-link`.quiet()
-
-      const patch = await Snapshot.patch(before!)
-      expect(patch.files).toContain(`${tmp.path}/sub/dir/link.txt`)
-      expect(patch.files).toContain(`${tmp.path}/sub-link`)
-    },
-  })
-})
-
-test("file permissions and ownership changes", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Change permissions multiple times
-      await $`chmod 600 ${tmp.path}/a.txt`.quiet()
-      await $`chmod 755 ${tmp.path}/a.txt`.quiet()
-      await $`chmod 644 ${tmp.path}/a.txt`.quiet()
-
-      const patch = await Snapshot.patch(before!)
-      // Note: git doesn't track permission changes on existing files by default
-      // Only tracks executable bit when files are first added
-      expect(patch.files.length).toBe(0)
-    },
-  })
-})
-
-test("circular symlinks", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Create circular symlink
-      await $`ln -s ${tmp.path}/circular ${tmp.path}/circular`.quiet().nothrow()
-
-      const patch = await Snapshot.patch(before!)
-      expect(patch.files.length).toBeGreaterThanOrEqual(0) // Should not crash
-    },
-  })
-})
-
-test("gitignore changes", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/.gitignore`, "*.ignored")
-      await Bun.write(`${tmp.path}/test.ignored`, "ignored content")
-      await Bun.write(`${tmp.path}/normal.txt`, "normal content")
-
-      const patch = await Snapshot.patch(before!)
-
-      // Should track gitignore itself
-      expect(patch.files).toContain(`${tmp.path}/.gitignore`)
-      // Should track normal files
-      expect(patch.files).toContain(`${tmp.path}/normal.txt`)
-      // Should not track ignored files (git won't see them)
-      expect(patch.files).not.toContain(`${tmp.path}/test.ignored`)
-    },
-  })
-})
-
-test("concurrent file operations during patch", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Start creating files
-      const createPromise = (async () => {
-        for (let i = 0; i < 10; i++) {
-          await Bun.write(`${tmp.path}/concurrent${i}.txt`, `concurrent${i}`)
-          // Small delay to simulate concurrent operations
-          await new Promise((resolve) => setTimeout(resolve, 1))
-        }
-      })()
-
-      // Get patch while files are being created
-      const patchPromise = Snapshot.patch(before!)
-
-      await createPromise
-      const patch = await patchPromise
-
-      // Should capture some or all of the concurrent files
-      expect(patch.files.length).toBeGreaterThanOrEqual(0)
-    },
-  })
-})
-
-test("snapshot state isolation between projects", async () => {
-  // Test that different projects don't interfere with each other
-  await using tmp1 = await bootstrap()
-  await using tmp2 = await bootstrap()
-
-  await Instance.provide({
-    directory: tmp1.path,
-    fn: async () => {
-      const before1 = await Snapshot.track()
-      await Bun.write(`${tmp1.path}/project1.txt`, "project1 content")
-      const patch1 = await Snapshot.patch(before1!)
-      expect(patch1.files).toContain(`${tmp1.path}/project1.txt`)
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp2.path,
-    fn: async () => {
-      const before2 = await Snapshot.track()
-      await Bun.write(`${tmp2.path}/project2.txt`, "project2 content")
-      const patch2 = await Snapshot.patch(before2!)
-      expect(patch2.files).toContain(`${tmp2.path}/project2.txt`)
-
-      // Ensure project1 files don't appear in project2
-      expect(patch2.files).not.toContain(`${tmp1?.path}/project1.txt`)
-    },
-  })
-})
-
-test("patch detects changes in secondary worktree", async () => {
-  await using tmp = await bootstrap()
-  const worktreePath = `${tmp.path}-worktree`
-  await $`git worktree add ${worktreePath} HEAD`.cwd(tmp.path).quiet()
-
-  try {
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        expect(await Snapshot.track()).toBeTruthy()
-      },
-    })
-
-    await Instance.provide({
-      directory: worktreePath,
-      fn: async () => {
-        const before = await Snapshot.track()
-        expect(before).toBeTruthy()
-
-        const worktreeFile = `${worktreePath}/worktree.txt`
-        await Bun.write(worktreeFile, "worktree content")
-
-        const patch = await Snapshot.patch(before!)
-        expect(patch.files).toContain(worktreeFile)
-      },
-    })
-  } finally {
-    await $`git worktree remove --force ${worktreePath}`.cwd(tmp.path).quiet().nothrow()
-    await $`rm -rf ${worktreePath}`.quiet()
-  }
-})
-
-test("revert only removes files in invoking worktree", async () => {
-  await using tmp = await bootstrap()
-  const worktreePath = `${tmp.path}-worktree`
-  await $`git worktree add ${worktreePath} HEAD`.cwd(tmp.path).quiet()
-
-  try {
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        expect(await Snapshot.track()).toBeTruthy()
-      },
-    })
-    const primaryFile = `${tmp.path}/worktree.txt`
-    await Bun.write(primaryFile, "primary content")
-
-    await Instance.provide({
-      directory: worktreePath,
-      fn: async () => {
-        const before = await Snapshot.track()
-        expect(before).toBeTruthy()
-
-        const worktreeFile = `${worktreePath}/worktree.txt`
-        await Bun.write(worktreeFile, "worktree content")
-
-        const patch = await Snapshot.patch(before!)
-        await Snapshot.revert([patch])
-
-        expect(await Bun.file(worktreeFile).exists()).toBe(false)
-      },
-    })
-
-    expect(await Bun.file(primaryFile).text()).toBe("primary content")
-  } finally {
-    await $`git worktree remove --force ${worktreePath}`.cwd(tmp.path).quiet().nothrow()
-    await $`rm -rf ${worktreePath}`.quiet()
-    await $`rm -f ${tmp.path}/worktree.txt`.quiet()
-  }
-})
-
-test("diff reports worktree-only/shared edits and ignores primary-only", async () => {
-  await using tmp = await bootstrap()
-  const worktreePath = `${tmp.path}-worktree`
-  await $`git worktree add ${worktreePath} HEAD`.cwd(tmp.path).quiet()
-
-  try {
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        expect(await Snapshot.track()).toBeTruthy()
-      },
-    })
-
-    await Instance.provide({
-      directory: worktreePath,
-      fn: async () => {
-        const before = await Snapshot.track()
-        expect(before).toBeTruthy()
-
-        await Bun.write(`${worktreePath}/worktree-only.txt`, "worktree diff content")
-        await Bun.write(`${worktreePath}/shared.txt`, "worktree edit")
-        await Bun.write(`${tmp.path}/shared.txt`, "primary edit")
-        await Bun.write(`${tmp.path}/primary-only.txt`, "primary change")
-
-        const diff = await Snapshot.diff(before!)
-        expect(diff).toContain("worktree-only.txt")
-        expect(diff).toContain("shared.txt")
-        expect(diff).not.toContain("primary-only.txt")
-      },
-    })
-  } finally {
-    await $`git worktree remove --force ${worktreePath}`.cwd(tmp.path).quiet().nothrow()
-    await $`rm -rf ${worktreePath}`.quiet()
-    await $`rm -f ${tmp.path}/shared.txt`.quiet()
-    await $`rm -f ${tmp.path}/primary-only.txt`.quiet()
-  }
-})
-
-test("track with no changes returns same hash", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const hash1 = await Snapshot.track()
-      expect(hash1).toBeTruthy()
-
-      // Track again with no changes
-      const hash2 = await Snapshot.track()
-      expect(hash2).toBe(hash1!)
-
-      // Track again
-      const hash3 = await Snapshot.track()
-      expect(hash3).toBe(hash1!)
-    },
-  })
-})
-
-test("diff function with various changes", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Make various changes
-      await $`rm ${tmp.path}/a.txt`.quiet()
-      await Bun.write(`${tmp.path}/new.txt`, "new content")
-      await Bun.write(`${tmp.path}/b.txt`, "modified content")
-
-      const diff = await Snapshot.diff(before!)
-      expect(diff).toContain("a.txt")
-      expect(diff).toContain("b.txt")
-      expect(diff).toContain("new.txt")
-    },
-  })
-})
-
-test("restore function", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Make changes
-      await $`rm ${tmp.path}/a.txt`.quiet()
-      await Bun.write(`${tmp.path}/new.txt`, "new content")
-      await Bun.write(`${tmp.path}/b.txt`, "modified")
-
-      // Restore to original state
-      await Snapshot.restore(before!)
-
-      expect(await Bun.file(`${tmp.path}/a.txt`).exists()).toBe(true)
-      expect(await Bun.file(`${tmp.path}/a.txt`).text()).toBe(tmp.extra.aContent)
-      expect(await Bun.file(`${tmp.path}/new.txt`).exists()).toBe(true) // New files should remain
-      expect(await Bun.file(`${tmp.path}/b.txt`).text()).toBe(tmp.extra.bContent)
-    },
-  })
-})
-
-test("revert should not delete files that existed but were deleted in snapshot", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const snapshot1 = await Snapshot.track()
-      expect(snapshot1).toBeTruthy()
-
-      await $`rm ${tmp.path}/a.txt`.quiet()
-
-      const snapshot2 = await Snapshot.track()
-      expect(snapshot2).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/a.txt`, "recreated content")
-
-      const patch = await Snapshot.patch(snapshot2!)
-      expect(patch.files).toContain(`${tmp.path}/a.txt`)
-
-      await Snapshot.revert([patch])
-
-      expect(await Bun.file(`${tmp.path}/a.txt`).exists()).toBe(false)
-    },
-  })
-})
-
-test("revert preserves file that existed in snapshot when deleted then recreated", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      await Bun.write(`${tmp.path}/existing.txt`, "original content")
-
-      const snapshot = await Snapshot.track()
-      expect(snapshot).toBeTruthy()
-
-      await $`rm ${tmp.path}/existing.txt`.quiet()
-      await Bun.write(`${tmp.path}/existing.txt`, "recreated")
-      await Bun.write(`${tmp.path}/newfile.txt`, "new")
-
-      const patch = await Snapshot.patch(snapshot!)
-      expect(patch.files).toContain(`${tmp.path}/existing.txt`)
-      expect(patch.files).toContain(`${tmp.path}/newfile.txt`)
-
-      await Snapshot.revert([patch])
-
-      expect(await Bun.file(`${tmp.path}/newfile.txt`).exists()).toBe(false)
-      expect(await Bun.file(`${tmp.path}/existing.txt`).exists()).toBe(true)
-      expect(await Bun.file(`${tmp.path}/existing.txt`).text()).toBe("original content")
-    },
-  })
-})
-
-test("diffFull with new file additions", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/new.txt`, "new content")
-
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.length).toBe(1)
-
-      const newFileDiff = diffs[0]
-      expect(newFileDiff.file).toBe("new.txt")
-      expect(newFileDiff.before).toBe("")
-      expect(newFileDiff.after).toBe("new content")
-      expect(newFileDiff.additions).toBe(1)
-      expect(newFileDiff.deletions).toBe(0)
-    },
-  })
-})
-
-test("diffFull with file modifications", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/b.txt`, "modified content")
-
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.length).toBe(1)
-
-      const modifiedFileDiff = diffs[0]
-      expect(modifiedFileDiff.file).toBe("b.txt")
-      expect(modifiedFileDiff.before).toBe(tmp.extra.bContent)
-      expect(modifiedFileDiff.after).toBe("modified content")
-      expect(modifiedFileDiff.additions).toBeGreaterThan(0)
-      expect(modifiedFileDiff.deletions).toBeGreaterThan(0)
-    },
-  })
-})
-
-test("diffFull with file deletions", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await $`rm ${tmp.path}/a.txt`.quiet()
-
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.length).toBe(1)
-
-      const removedFileDiff = diffs[0]
-      expect(removedFileDiff.file).toBe("a.txt")
-      expect(removedFileDiff.before).toBe(tmp.extra.aContent)
-      expect(removedFileDiff.after).toBe("")
-      expect(removedFileDiff.additions).toBe(0)
-      expect(removedFileDiff.deletions).toBe(1)
-    },
-  })
-})
-
-test("diffFull with multiple line additions", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/multi.txt`, "line1\nline2\nline3")
-
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.length).toBe(1)
-
-      const multiDiff = diffs[0]
-      expect(multiDiff.file).toBe("multi.txt")
-      expect(multiDiff.before).toBe("")
-      expect(multiDiff.after).toBe("line1\nline2\nline3")
-      expect(multiDiff.additions).toBe(3)
-      expect(multiDiff.deletions).toBe(0)
-    },
-  })
-})
-
-test("diffFull with addition and deletion", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/added.txt`, "added content")
-      await $`rm ${tmp.path}/a.txt`.quiet()
-
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.length).toBe(2)
-
-      const addedFileDiff = diffs.find((d) => d.file === "added.txt")
-      expect(addedFileDiff).toBeDefined()
-      expect(addedFileDiff!.before).toBe("")
-      expect(addedFileDiff!.after).toBe("added content")
-      expect(addedFileDiff!.additions).toBe(1)
-      expect(addedFileDiff!.deletions).toBe(0)
-
-      const removedFileDiff = diffs.find((d) => d.file === "a.txt")
-      expect(removedFileDiff).toBeDefined()
-      expect(removedFileDiff!.before).toBe(tmp.extra.aContent)
-      expect(removedFileDiff!.after).toBe("")
-      expect(removedFileDiff!.additions).toBe(0)
-      expect(removedFileDiff!.deletions).toBe(1)
-    },
-  })
-})
-
-test("diffFull with multiple additions and deletions", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/multi1.txt`, "line1\nline2\nline3")
-      await Bun.write(`${tmp.path}/multi2.txt`, "single line")
-      await $`rm ${tmp.path}/a.txt`.quiet()
-      await $`rm ${tmp.path}/b.txt`.quiet()
-
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.length).toBe(4)
-
-      const multi1Diff = diffs.find((d) => d.file === "multi1.txt")
-      expect(multi1Diff).toBeDefined()
-      expect(multi1Diff!.additions).toBe(3)
-      expect(multi1Diff!.deletions).toBe(0)
-
-      const multi2Diff = diffs.find((d) => d.file === "multi2.txt")
-      expect(multi2Diff).toBeDefined()
-      expect(multi2Diff!.additions).toBe(1)
-      expect(multi2Diff!.deletions).toBe(0)
-
-      const removedADiff = diffs.find((d) => d.file === "a.txt")
-      expect(removedADiff).toBeDefined()
-      expect(removedADiff!.additions).toBe(0)
-      expect(removedADiff!.deletions).toBe(1)
-
-      const removedBDiff = diffs.find((d) => d.file === "b.txt")
-      expect(removedBDiff).toBeDefined()
-      expect(removedBDiff!.additions).toBe(0)
-      expect(removedBDiff!.deletions).toBe(1)
-    },
-  })
-})
-
-test("diffFull with no changes", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.length).toBe(0)
-    },
-  })
-})
-
-test("diffFull with binary file changes", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/binary.bin`, new Uint8Array([0x00, 0x01, 0x02, 0x03]))
-
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.length).toBe(1)
-
-      const binaryDiff = diffs[0]
-      expect(binaryDiff.file).toBe("binary.bin")
-      expect(binaryDiff.before).toBe("")
-    },
-  })
-})
-
-test("diffFull with whitespace changes", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      await Bun.write(`${tmp.path}/whitespace.txt`, "line1\nline2")
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      await Bun.write(`${tmp.path}/whitespace.txt`, "line1\n\nline2\n")
-
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.length).toBe(1)
-
-      const whitespaceDiff = diffs[0]
-      expect(whitespaceDiff.file).toBe("whitespace.txt")
-      expect(whitespaceDiff.additions).toBeGreaterThan(0)
-    },
-  })
-})