chore: format code

packages/opencode/test/snapshot/snapshot.test.ts

@@ -27,356 +27,419 @@ async function bootstrap() {
 
 test("tracks deleted files correctly", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    await $`rm ${tmp.dir}/a.txt`.quiet()
+      await $`rm ${tmp.dir}/a.txt`.quiet()
 
-    expect((await Snapshot.patch(before!)).files).toContain(`${tmp.dir}/a.txt`)
-  }})
+      expect((await Snapshot.patch(before!)).files).toContain(`${tmp.dir}/a.txt`)
+    },
+  })
 })
 
 test("revert should remove new files", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    await Bun.write(`${tmp.dir}/new.txt`, "NEW")
+      await Bun.write(`${tmp.dir}/new.txt`, "NEW")
 
-    await Snapshot.revert([await Snapshot.patch(before!)])
+      await Snapshot.revert([await Snapshot.patch(before!)])
 
-    expect(await Bun.file(`${tmp.dir}/new.txt`).exists()).toBe(false)
-  }})
+      expect(await Bun.file(`${tmp.dir}/new.txt`).exists()).toBe(false)
+    },
+  })
 })
 
 test("revert in subdirectory", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    await $`mkdir -p ${tmp.dir}/sub`.quiet()
-    await Bun.write(`${tmp.dir}/sub/file.txt`, "SUB")
+      await $`mkdir -p ${tmp.dir}/sub`.quiet()
+      await Bun.write(`${tmp.dir}/sub/file.txt`, "SUB")
 
-    await Snapshot.revert([await Snapshot.patch(before!)])
+      await Snapshot.revert([await Snapshot.patch(before!)])
 
-    expect(await Bun.file(`${tmp.dir}/sub/file.txt`).exists()).toBe(false)
-    // Note: revert currently only removes files, not directories
-    // The empty subdirectory will remain
-  }})
+      expect(await Bun.file(`${tmp.dir}/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.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    await $`rm ${tmp.dir}/a.txt`.quiet()
-    await Bun.write(`${tmp.dir}/c.txt`, "C")
-    await $`mkdir -p ${tmp.dir}/dir`.quiet()
-    await Bun.write(`${tmp.dir}/dir/d.txt`, "D")
-    await Bun.write(`${tmp.dir}/b.txt`, "MODIFIED")
-
-    await Snapshot.revert([await Snapshot.patch(before!)])
-
-    expect(await Bun.file(`${tmp.dir}/a.txt`).text()).toBe(tmp.aContent)
-    expect(await Bun.file(`${tmp.dir}/c.txt`).exists()).toBe(false)
-    // Note: revert currently only removes files, not directories
-    // The empty directory will remain
-    expect(await Bun.file(`${tmp.dir}/b.txt`).text()).toBe(tmp.bContent)
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      await $`rm ${tmp.dir}/a.txt`.quiet()
+      await Bun.write(`${tmp.dir}/c.txt`, "C")
+      await $`mkdir -p ${tmp.dir}/dir`.quiet()
+      await Bun.write(`${tmp.dir}/dir/d.txt`, "D")
+      await Bun.write(`${tmp.dir}/b.txt`, "MODIFIED")
+
+      await Snapshot.revert([await Snapshot.patch(before!)])
+
+      expect(await Bun.file(`${tmp.dir}/a.txt`).text()).toBe(tmp.aContent)
+      expect(await Bun.file(`${tmp.dir}/c.txt`).exists()).toBe(false)
+      // Note: revert currently only removes files, not directories
+      // The empty directory will remain
+      expect(await Bun.file(`${tmp.dir}/b.txt`).text()).toBe(tmp.bContent)
+    },
+  })
 })
 
 test("empty directory handling", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    await $`mkdir ${tmp.dir}/empty`.quiet()
+      await $`mkdir ${tmp.dir}/empty`.quiet()
 
-    expect((await Snapshot.patch(before!)).files.length).toBe(0)
-  }})
+      expect((await Snapshot.patch(before!)).files.length).toBe(0)
+    },
+  })
 })
 
 test("binary file handling", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    await Bun.write(`${tmp.dir}/image.png`, Buffer.from([0x89, 0x50, 0x4e, 0x47]))
+      await Bun.write(`${tmp.dir}/image.png`, Buffer.from([0x89, 0x50, 0x4e, 0x47]))
 
-    const patch = await Snapshot.patch(before!)
-    expect(patch.files).toContain(`${tmp.dir}/image.png`)
+      const patch = await Snapshot.patch(before!)
+      expect(patch.files).toContain(`${tmp.dir}/image.png`)
 
-    await Snapshot.revert([patch])
-    expect(await Bun.file(`${tmp.dir}/image.png`).exists()).toBe(false)
-  }})
+      await Snapshot.revert([patch])
+      expect(await Bun.file(`${tmp.dir}/image.png`).exists()).toBe(false)
+    },
+  })
 })
 
 test("symlink handling", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    await $`ln -s ${tmp.dir}/a.txt ${tmp.dir}/link.txt`.quiet()
+      await $`ln -s ${tmp.dir}/a.txt ${tmp.dir}/link.txt`.quiet()
 
-    expect((await Snapshot.patch(before!)).files).toContain(`${tmp.dir}/link.txt`)
-  }})
+      expect((await Snapshot.patch(before!)).files).toContain(`${tmp.dir}/link.txt`)
+    },
+  })
 })
 
 test("large file handling", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    await Bun.write(`${tmp.dir}/large.txt`, "x".repeat(1024 * 1024))
+      await Bun.write(`${tmp.dir}/large.txt`, "x".repeat(1024 * 1024))
 
-    expect((await Snapshot.patch(before!)).files).toContain(`${tmp.dir}/large.txt`)
-  }})
+      expect((await Snapshot.patch(before!)).files).toContain(`${tmp.dir}/large.txt`)
+    },
+  })
 })
 
 test("nested directory revert", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    await $`mkdir -p ${tmp.dir}/level1/level2/level3`.quiet()
-    await Bun.write(`${tmp.dir}/level1/level2/level3/deep.txt`, "DEEP")
+      await $`mkdir -p ${tmp.dir}/level1/level2/level3`.quiet()
+      await Bun.write(`${tmp.dir}/level1/level2/level3/deep.txt`, "DEEP")
 
-    await Snapshot.revert([await Snapshot.patch(before!)])
+      await Snapshot.revert([await Snapshot.patch(before!)])
 
-    expect(await Bun.file(`${tmp.dir}/level1/level2/level3/deep.txt`).exists()).toBe(false)
-  }})
+      expect(await Bun.file(`${tmp.dir}/level1/level2/level3/deep.txt`).exists()).toBe(false)
+    },
+  })
 })
 
 test("special characters in filenames", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    await Bun.write(`${tmp.dir}/file with spaces.txt`, "SPACES")
-    await Bun.write(`${tmp.dir}/file-with-dashes.txt`, "DASHES")
-    await Bun.write(`${tmp.dir}/file_with_underscores.txt`, "UNDERSCORES")
-
-    const files = (await Snapshot.patch(before!)).files
-    expect(files).toContain(`${tmp.dir}/file with spaces.txt`)
-    expect(files).toContain(`${tmp.dir}/file-with-dashes.txt`)
-    expect(files).toContain(`${tmp.dir}/file_with_underscores.txt`)
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      await Bun.write(`${tmp.dir}/file with spaces.txt`, "SPACES")
+      await Bun.write(`${tmp.dir}/file-with-dashes.txt`, "DASHES")
+      await Bun.write(`${tmp.dir}/file_with_underscores.txt`, "UNDERSCORES")
+
+      const files = (await Snapshot.patch(before!)).files
+      expect(files).toContain(`${tmp.dir}/file with spaces.txt`)
+      expect(files).toContain(`${tmp.dir}/file-with-dashes.txt`)
+      expect(files).toContain(`${tmp.dir}/file_with_underscores.txt`)
+    },
+  })
 })
 
 test("revert with empty patches", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, 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()
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    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.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    // Create a change
-    await Bun.write(`${tmp.dir}/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")
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      // Create a change
+      await Bun.write(`${tmp.dir}/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.dir, 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.dir}/nonexistent.txt`],
-        },
-      ]),
-    ).resolves.toBeUndefined()
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    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.dir}/nonexistent.txt`],
+          },
+        ]),
+      ).resolves.toBeUndefined()
+    },
+  })
 })
 
 test("unicode filenames", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    const unicodeFiles = [
-      `${tmp.dir}/文件.txt`,
-      `${tmp.dir}/🚀rocket.txt`,
-      `${tmp.dir}/café.txt`,
-      `${tmp.dir}/файл.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
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      const unicodeFiles = [
+        `${tmp.dir}/文件.txt`,
+        `${tmp.dir}/🚀rocket.txt`,
+        `${tmp.dir}/café.txt`,
+        `${tmp.dir}/файл.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.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    const longName = "a".repeat(200) + ".txt"
-    const longFile = `${tmp.dir}/${longName}`
+      const longName = "a".repeat(200) + ".txt"
+      const longFile = `${tmp.dir}/${longName}`
 
-    await Bun.write(longFile, "long filename content")
+      await Bun.write(longFile, "long filename content")
 
-    const patch = await Snapshot.patch(before!)
-    expect(patch.files).toContain(longFile)
+      const patch = await Snapshot.patch(before!)
+      expect(patch.files).toContain(longFile)
 
-    await Snapshot.revert([patch])
-    expect(await Bun.file(longFile).exists()).toBe(false)
-  }})
+      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.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    await Bun.write(`${tmp.dir}/.hidden`, "hidden content")
-    await Bun.write(`${tmp.dir}/.gitignore`, "*.log")
-    await Bun.write(`${tmp.dir}/.config`, "config content")
-
-    const patch = await Snapshot.patch(before!)
-    expect(patch.files).toContain(`${tmp.dir}/.hidden`)
-    expect(patch.files).toContain(`${tmp.dir}/.gitignore`)
-    expect(patch.files).toContain(`${tmp.dir}/.config`)
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      await Bun.write(`${tmp.dir}/.hidden`, "hidden content")
+      await Bun.write(`${tmp.dir}/.gitignore`, "*.log")
+      await Bun.write(`${tmp.dir}/.config`, "config content")
+
+      const patch = await Snapshot.patch(before!)
+      expect(patch.files).toContain(`${tmp.dir}/.hidden`)
+      expect(patch.files).toContain(`${tmp.dir}/.gitignore`)
+      expect(patch.files).toContain(`${tmp.dir}/.config`)
+    },
+  })
 })
 
 test("nested symlinks", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    await $`mkdir -p ${tmp.dir}/sub/dir`.quiet()
-    await Bun.write(`${tmp.dir}/sub/dir/target.txt`, "target content")
-    await $`ln -s ${tmp.dir}/sub/dir/target.txt ${tmp.dir}/sub/dir/link.txt`.quiet()
-    await $`ln -s ${tmp.dir}/sub ${tmp.dir}/sub-link`.quiet()
-
-    const patch = await Snapshot.patch(before!)
-    expect(patch.files).toContain(`${tmp.dir}/sub/dir/link.txt`)
-    expect(patch.files).toContain(`${tmp.dir}/sub-link`)
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      await $`mkdir -p ${tmp.dir}/sub/dir`.quiet()
+      await Bun.write(`${tmp.dir}/sub/dir/target.txt`, "target content")
+      await $`ln -s ${tmp.dir}/sub/dir/target.txt ${tmp.dir}/sub/dir/link.txt`.quiet()
+      await $`ln -s ${tmp.dir}/sub ${tmp.dir}/sub-link`.quiet()
+
+      const patch = await Snapshot.patch(before!)
+      expect(patch.files).toContain(`${tmp.dir}/sub/dir/link.txt`)
+      expect(patch.files).toContain(`${tmp.dir}/sub-link`)
+    },
+  })
 })
 
 test("file permissions and ownership changes", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    // Change permissions multiple times
-    await $`chmod 600 ${tmp.dir}/a.txt`.quiet()
-    await $`chmod 755 ${tmp.dir}/a.txt`.quiet()
-    await $`chmod 644 ${tmp.dir}/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)
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      // Change permissions multiple times
+      await $`chmod 600 ${tmp.dir}/a.txt`.quiet()
+      await $`chmod 755 ${tmp.dir}/a.txt`.quiet()
+      await $`chmod 644 ${tmp.dir}/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.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
 
-    // Create circular symlink
-    await $`ln -s ${tmp.dir}/circular ${tmp.dir}/circular`.quiet().nothrow()
+      // Create circular symlink
+      await $`ln -s ${tmp.dir}/circular ${tmp.dir}/circular`.quiet().nothrow()
 
-    const patch = await Snapshot.patch(before!)
-    expect(patch.files.length).toBeGreaterThanOrEqual(0) // Should not crash
-  }})
+      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.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    await Bun.write(`${tmp.dir}/.gitignore`, "*.ignored")
-    await Bun.write(`${tmp.dir}/test.ignored`, "ignored content")
-    await Bun.write(`${tmp.dir}/normal.txt`, "normal content")
-
-    const patch = await Snapshot.patch(before!)
-
-    // Should track gitignore itself
-    expect(patch.files).toContain(`${tmp.dir}/.gitignore`)
-    // Should track normal files
-    expect(patch.files).toContain(`${tmp.dir}/normal.txt`)
-    // Should not track ignored files (git won't see them)
-    expect(patch.files).not.toContain(`${tmp.dir}/test.ignored`)
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      await Bun.write(`${tmp.dir}/.gitignore`, "*.ignored")
+      await Bun.write(`${tmp.dir}/test.ignored`, "ignored content")
+      await Bun.write(`${tmp.dir}/normal.txt`, "normal content")
+
+      const patch = await Snapshot.patch(before!)
+
+      // Should track gitignore itself
+      expect(patch.files).toContain(`${tmp.dir}/.gitignore`)
+      // Should track normal files
+      expect(patch.files).toContain(`${tmp.dir}/normal.txt`)
+      // Should not track ignored files (git won't see them)
+      expect(patch.files).not.toContain(`${tmp.dir}/test.ignored`)
+    },
+  })
 })
 
 test("concurrent file operations during patch", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, 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.dir}/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)
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    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.dir}/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 () => {
@@ -384,75 +447,90 @@ test("snapshot state isolation between projects", async () => {
   await using tmp1 = await bootstrap()
   await using tmp2 = await bootstrap()
 
-  await Instance.provide({ directory: tmp1.dir, fn: async () => {
-    const before1 = await Snapshot.track()
-    await Bun.write(`${tmp1.dir}/project1.txt`, "project1 content")
-    const patch1 = await Snapshot.patch(before1!)
-    expect(patch1.files).toContain(`${tmp1.dir}/project1.txt`)
-  }})
-
-  await Instance.provide({ directory: tmp2.dir, fn: async () => {
-    const before2 = await Snapshot.track()
-    await Bun.write(`${tmp2.dir}/project2.txt`, "project2 content")
-    const patch2 = await Snapshot.patch(before2!)
-    expect(patch2.files).toContain(`${tmp2.dir}/project2.txt`)
-
-    // Ensure project1 files don't appear in project2
-    expect(patch2.files).not.toContain(`${tmp1?.dir}/project1.txt`)
-  }})
+  await Instance.provide({
+    directory: tmp1.dir,
+    fn: async () => {
+      const before1 = await Snapshot.track()
+      await Bun.write(`${tmp1.dir}/project1.txt`, "project1 content")
+      const patch1 = await Snapshot.patch(before1!)
+      expect(patch1.files).toContain(`${tmp1.dir}/project1.txt`)
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp2.dir,
+    fn: async () => {
+      const before2 = await Snapshot.track()
+      await Bun.write(`${tmp2.dir}/project2.txt`, "project2 content")
+      const patch2 = await Snapshot.patch(before2!)
+      expect(patch2.files).toContain(`${tmp2.dir}/project2.txt`)
+
+      // Ensure project1 files don't appear in project2
+      expect(patch2.files).not.toContain(`${tmp1?.dir}/project1.txt`)
+    },
+  })
 })
 
 test("track with no changes returns same hash", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, 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!)
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    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.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    // Make various changes
-    await $`rm ${tmp.dir}/a.txt`.quiet()
-    await Bun.write(`${tmp.dir}/new.txt`, "new content")
-    await Bun.write(`${tmp.dir}/b.txt`, "modified content")
-
-    const diff = await Snapshot.diff(before!)
-    expect(diff).toContain("deleted")
-    expect(diff).toContain("modified")
-    // Note: git diff only shows changes to tracked files, not untracked files like new.txt
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      // Make various changes
+      await $`rm ${tmp.dir}/a.txt`.quiet()
+      await Bun.write(`${tmp.dir}/new.txt`, "new content")
+      await Bun.write(`${tmp.dir}/b.txt`, "modified content")
+
+      const diff = await Snapshot.diff(before!)
+      expect(diff).toContain("deleted")
+      expect(diff).toContain("modified")
+      // Note: git diff only shows changes to tracked files, not untracked files like new.txt
+    },
+  })
 })
 
 test("restore function", async () => {
   await using tmp = await bootstrap()
-  await Instance.provide({ directory: tmp.dir, fn: async () => {
-    const before = await Snapshot.track()
-    expect(before).toBeTruthy()
-
-    // Make changes
-    await $`rm ${tmp.dir}/a.txt`.quiet()
-    await Bun.write(`${tmp.dir}/new.txt`, "new content")
-    await Bun.write(`${tmp.dir}/b.txt`, "modified")
-
-    // Restore to original state
-    await Snapshot.restore(before!)
-
-    expect(await Bun.file(`${tmp.dir}/a.txt`).exists()).toBe(true)
-    expect(await Bun.file(`${tmp.dir}/a.txt`).text()).toBe(tmp.aContent)
-    expect(await Bun.file(`${tmp.dir}/new.txt`).exists()).toBe(true) // New files should remain
-    expect(await Bun.file(`${tmp.dir}/b.txt`).text()).toBe(tmp.bContent)
-  }})
+  await Instance.provide({
+    directory: tmp.dir,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      // Make changes
+      await $`rm ${tmp.dir}/a.txt`.quiet()
+      await Bun.write(`${tmp.dir}/new.txt`, "new content")
+      await Bun.write(`${tmp.dir}/b.txt`, "modified")
+
+      // Restore to original state
+      await Snapshot.restore(before!)
+
+      expect(await Bun.file(`${tmp.dir}/a.txt`).exists()).toBe(true)
+      expect(await Bun.file(`${tmp.dir}/a.txt`).text()).toBe(tmp.aContent)
+      expect(await Bun.file(`${tmp.dir}/new.txt`).exists()).toBe(true) // New files should remain
+      expect(await Bun.file(`${tmp.dir}/b.txt`).text()).toBe(tmp.bContent)
+    },
+  })
 })