openAgent

1import { afterEach, expect } from "bun:test"
2import { $ } from "bun"
3import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
4import { LayerNode } from "@opencode-ai/core/effect/layer-node"
5import { FSUtil } from "@opencode-ai/core/fs-util"
6import fs from "fs/promises"
7import path from "path"
8import { Effect, Fiber, Layer } from "effect"
9import { Snapshot } from "../../src/snapshot"
10import {
11  disposeAllInstances,
12  provideInstance,
13  testInstanceStoreLayer,
14  TestInstance,
15  tmpdirScoped,
16} from "../fixture/fixture"
17import { testEffect } from "../lib/effect"
18 
19const it = testEffect(
20  Layer.mergeAll(LayerNode.compile(LayerNode.group([Snapshot.node, FSUtil.node])), testInstanceStoreLayer),
21)
22// Windows forbids both * and : in directory names.
23const nonWindowsIt = process.platform === "win32" ? it.live.skip : it.live
24 
25// Git always outputs /-separated paths internally. Snapshot.patch() joins them
26// with path.join (which produces \ on Windows) then normalizes back to /.
27// This helper does the same for expected values so assertions match cross-platform.
28const fwd = (...parts: string[]) => path.join(...parts).replaceAll("\\", "/")
29const SNAPSHOT_BATCH_BOUNDARY = 100
30const OVER_BATCH_COUNT = SNAPSHOT_BATCH_BOUNDARY + 1
31const MIXED_BATCH_GROUP_COUNT = Math.ceil(OVER_BATCH_COUNT / 4)
32 
33afterEach(async () => {
34  await disposeAllInstances()
35})
36 
37const exec = (cwd: string, command: string[]) =>
38  Effect.promise(async () => {
39    const proc = Bun.spawn(command, { cwd, stdout: "ignore", stderr: "pipe" })
40    const code = await proc.exited
41    if (code !== 0) throw new Error(`${command.join(" ")} failed: ${await new Response(proc.stderr).text()}`)
42  })
43 
44const write = (file: string, content: string | Uint8Array) =>
45  FSUtil.Service.use((fs) => fs.writeWithDirs(file, content))
46const readText = (file: string) => FSUtil.Service.use((fs) => fs.readFileString(file))
47const exists = (file: string) => FSUtil.Service.use((fs) => fs.existsSafe(file))
48const mkdirp = (dir: string) => FSUtil.Service.use((fs) => fs.ensureDir(dir))
49const rm = (file: string) =>
50  FSUtil.Service.use((fs) => fs.remove(file, { recursive: true, force: true }).pipe(Effect.ignore))
51 
52const initialize = Effect.fn("SnapshotTest.initialize")(function* (dir: string) {
53  const unique = Math.random().toString(36).slice(2)
54  const aContent = `A${unique}`
55  const bContent = `B${unique}`
56  yield* write(`${dir}/a.txt`, aContent)
57  yield* write(`${dir}/b.txt`, bContent)
58  return { aContent, bContent }
59})
60 
61type Bootstrapped = { path: string; extra: { aContent: string; bContent: string } }
62 
63const bootstrap = Effect.fn("SnapshotTest.bootstrap")(function* () {
64  const tmp = yield* TestInstance
65  return { path: tmp.directory, extra: yield* initialize(tmp.directory) }
66})
67 
68const withTrackedSnapshot = <A, E, R>(
69  fn: (input: { tmp: Bootstrapped; snapshot: Snapshot.Interface; before: string }) => Effect.Effect<A, E, R>,
70) =>
71  Effect.gen(function* () {
72    const tmp = yield* bootstrap()
73    const snapshot = yield* Snapshot.Service
74    const before = yield* snapshot.track()
75    expect(before).toBeTruthy()
76    return yield* fn({ tmp, snapshot, before: before! })
77  })
78 
79const bootstrapScoped = Effect.fn("SnapshotTest.bootstrapScoped")(function* () {
80  const dir = yield* tmpdirScoped({ git: true }).pipe(Effect.provide(LayerNode.compile(CrossSpawnSpawner.node)))
81  return { path: dir, extra: yield* initialize(dir) }
82})
83 
84const scopedGitTmpdir = () =>
85  tmpdirScoped({ git: true }).pipe(Effect.provide(LayerNode.compile(CrossSpawnSpawner.node)))
86 
87const cleanupWorktree = (repo: string, worktree: string, files: string[] = []) =>
88  Effect.promise(async () => {
89    await $`git worktree remove --force ${worktree}`.cwd(repo).quiet().nothrow()
90    await fs.rm(worktree, { recursive: true, force: true }).catch(() => undefined)
91    await Promise.all(files.map((file) => fs.rm(file, { recursive: true, force: true }).catch(() => undefined)))
92  })
93 
94const withGitConfigGlobal = <A, E, R>(config: string, self: Effect.Effect<A, E, R>) =>
95  Effect.acquireUseRelease(
96    Effect.sync(() => {
97      const previous = process.env.GIT_CONFIG_GLOBAL
98      process.env.GIT_CONFIG_GLOBAL = config
99      return previous
100    }),
101    () => self,
102    (previous) =>
103      Effect.sync(() => {
104        if (previous) process.env.GIT_CONFIG_GLOBAL = previous
105        else delete process.env.GIT_CONFIG_GLOBAL
106      }),
107  )
108 
109it.instance(
110  "tracks deleted files correctly",
111  withTrackedSnapshot(({ tmp, snapshot, before }) =>
112    Effect.gen(function* () {
113      yield* rm(`${tmp.path}/a.txt`)
114      expect((yield* snapshot.patch(before)).files).toContain(fwd(tmp.path, "a.txt"))
115    }),
116  ),
117  { git: true },
118)
119 
120it.instance(
121  "revert should remove new files",
122  withTrackedSnapshot(({ tmp, snapshot, before }) =>
123    Effect.gen(function* () {
124      yield* write(`${tmp.path}/new.txt`, "NEW")
125      const patch = yield* snapshot.patch(before)
126      yield* snapshot.revert([patch])
127      expect(yield* exists(`${tmp.path}/new.txt`)).toBe(false)
128    }),
129  ),
130  { git: true },
131)
132 
133it.instance(
134  "revert in subdirectory",
135  withTrackedSnapshot(({ tmp, snapshot, before }) =>
136    Effect.gen(function* () {
137      yield* mkdirp(`${tmp.path}/sub`)
138      yield* write(`${tmp.path}/sub/file.txt`, "SUB")
139      const patch = yield* snapshot.patch(before)
140      yield* snapshot.revert([patch])
141      expect(yield* exists(`${tmp.path}/sub/file.txt`)).toBe(false)
142    }),
143  ),
144  { git: true },
145)
146 
147it.instance(
148  "multiple file operations",
149  withTrackedSnapshot(({ tmp, snapshot, before }) =>
150    Effect.gen(function* () {
151      yield* rm(`${tmp.path}/a.txt`)
152      yield* write(`${tmp.path}/c.txt`, "C")
153      yield* mkdirp(`${tmp.path}/dir`)
154      yield* write(`${tmp.path}/dir/d.txt`, "D")
155      yield* write(`${tmp.path}/b.txt`, "MODIFIED")
156      const patch = yield* snapshot.patch(before)
157      yield* snapshot.revert([patch])
158      expect(yield* readText(`${tmp.path}/a.txt`)).toBe(tmp.extra.aContent)
159      expect(yield* exists(`${tmp.path}/c.txt`)).toBe(false)
160      expect(yield* readText(`${tmp.path}/b.txt`)).toBe(tmp.extra.bContent)
161    }),
162  ),
163  { git: true },
164)
165 
166it.instance(
167  "empty directory handling",
168  withTrackedSnapshot(({ tmp, snapshot, before }) =>
169    Effect.gen(function* () {
170      yield* mkdirp(`${tmp.path}/empty`)
171      expect((yield* snapshot.patch(before)).files.length).toBe(0)
172    }),
173  ),
174  { git: true },
175)
176 
177it.instance(
178  "binary file handling",
179  withTrackedSnapshot(({ tmp, snapshot, before }) =>
180    Effect.gen(function* () {
181      yield* write(`${tmp.path}/image.png`, new Uint8Array([0x89, 0x50, 0x4e, 0x47]))
182      const patch = yield* snapshot.patch(before)
183      expect(patch.files).toContain(fwd(tmp.path, "image.png"))
184      yield* snapshot.revert([patch])
185      expect(yield* exists(`${tmp.path}/image.png`)).toBe(false)
186    }),
187  ),
188  { git: true },
189)
190 
191it.instance(
192  "symlink handling",
193  withTrackedSnapshot(({ tmp, snapshot, before }) =>
194    Effect.gen(function* () {
195      yield* Effect.promise(() => fs.symlink(`${tmp.path}/a.txt`, `${tmp.path}/link.txt`, "file"))
196      expect((yield* snapshot.patch(before)).files).toContain(fwd(tmp.path, "link.txt"))
197    }),
198  ),
199  { git: true },
200)
201 
202it.instance(
203  "file under size limit handling",
204  withTrackedSnapshot(({ tmp, snapshot, before }) =>
205    Effect.gen(function* () {
206      yield* write(`${tmp.path}/large.txt`, "x".repeat(1024 * 1024))
207      expect((yield* snapshot.patch(before)).files).toContain(fwd(tmp.path, "large.txt"))
208    }),
209  ),
210  { git: true },
211)
212 
213it.instance(
214  "large added files are skipped",
215  withTrackedSnapshot(({ tmp, snapshot, before }) =>
216    Effect.gen(function* () {
217      yield* write(`${tmp.path}/huge.txt`, new Uint8Array(2 * 1024 * 1024 + 1))
218      expect((yield* snapshot.patch(before)).files).toEqual([])
219      expect(yield* snapshot.diff(before)).toBe("")
220      expect(yield* snapshot.track()).toBe(before)
221    }),
222  ),
223  { git: true },
224)
225 
226it.instance(
227  "nested directory revert",
228  withTrackedSnapshot(({ tmp, snapshot, before }) =>
229    Effect.gen(function* () {
230      yield* mkdirp(`${tmp.path}/level1/level2/level3`)
231      yield* write(`${tmp.path}/level1/level2/level3/deep.txt`, "DEEP")
232      const patch = yield* snapshot.patch(before)
233      yield* snapshot.revert([patch])
234      expect(yield* exists(`${tmp.path}/level1/level2/level3/deep.txt`)).toBe(false)
235    }),
236  ),
237  { git: true },
238)
239 
240it.instance(
241  "special characters in filenames",
242  withTrackedSnapshot(({ tmp, snapshot, before }) =>
243    Effect.gen(function* () {
244      yield* write(`${tmp.path}/file with spaces.txt`, "SPACES")
245      yield* write(`${tmp.path}/file-with-dashes.txt`, "DASHES")
246      yield* write(`${tmp.path}/file_with_underscores.txt`, "UNDERSCORES")
247      const files = (yield* snapshot.patch(before)).files
248      expect(files).toContain(fwd(tmp.path, "file with spaces.txt"))
249      expect(files).toContain(fwd(tmp.path, "file-with-dashes.txt"))
250      expect(files).toContain(fwd(tmp.path, "file_with_underscores.txt"))
251    }),
252  ),
253  { git: true },
254)
255 
256it.instance(
257  "revert with empty patches",
258  Effect.gen(function* () {
259    yield* bootstrap()
260    const snapshot = yield* Snapshot.Service
261    yield* snapshot.revert([])
262    yield* snapshot.revert([{ hash: "dummy", files: [] }])
263  }),
264  { git: true },
265)
266 
267it.instance(
268  "patch with invalid hash",
269  withTrackedSnapshot(({ tmp, snapshot }) =>
270    Effect.gen(function* () {
271      yield* write(`${tmp.path}/test.txt`, "TEST")
272      const patch = yield* snapshot.patch("invalid-hash-12345")
273      expect(patch.files).toEqual([])
274      expect(patch.hash).toBe("invalid-hash-12345")
275    }),
276  ),
277  { git: true },
278)
279 
280it.instance(
281  "revert non-existent file",
282  withTrackedSnapshot(({ tmp, snapshot, before }) =>
283    Effect.gen(function* () {
284      yield* snapshot.revert([{ hash: before, files: [`${tmp.path}/nonexistent.txt`] }])
285    }),
286  ),
287  { git: true },
288)
289 
290it.instance(
291  "unicode filenames",
292  withTrackedSnapshot(({ tmp, snapshot, before }) =>
293    Effect.gen(function* () {
294      const unicodeFiles = [
295        { path: fwd(tmp.path, "文件.txt"), content: "chinese content" },
296        { path: fwd(tmp.path, "🚀rocket.txt"), content: "emoji content" },
297        { path: fwd(tmp.path, "café.txt"), content: "accented content" },
298        { path: fwd(tmp.path, "файл.txt"), content: "cyrillic content" },
299      ]
300      yield* Effect.all(
301        unicodeFiles.map((file) => write(file.path, file.content)),
302        { concurrency: "unbounded" },
303      )
304      const patch = yield* snapshot.patch(before)
305      expect(patch.files.length).toBe(4)
306      for (const file of unicodeFiles) expect(patch.files).toContain(file.path)
307      yield* snapshot.revert([patch])
308      for (const file of unicodeFiles) expect(yield* exists(file.path)).toBe(false)
309    }),
310  ),
311  { git: true },
312)
313 
314it.instance.skip(
315  "unicode filenames modification and restore",
316  Effect.gen(function* () {
317    const tmp = yield* bootstrap()
318    const snapshot = yield* Snapshot.Service
319    const chineseFile = fwd(tmp.path, "文件.txt")
320    const cyrillicFile = fwd(tmp.path, "файл.txt")
321    yield* write(chineseFile, "original chinese")
322    yield* write(cyrillicFile, "original cyrillic")
323    const before = yield* snapshot.track()
324    expect(before).toBeTruthy()
325    yield* write(chineseFile, "modified chinese")
326    yield* write(cyrillicFile, "modified cyrillic")
327    const patch = yield* snapshot.patch(before!)
328    expect(patch.files).toContain(chineseFile)
329    expect(patch.files).toContain(cyrillicFile)
330    yield* snapshot.revert([patch])
331    expect(yield* readText(chineseFile)).toBe("original chinese")
332    expect(yield* readText(cyrillicFile)).toBe("original cyrillic")
333  }),
334  { git: true },
335)
336 
337it.instance(
338  "unicode filenames in subdirectories",
339  withTrackedSnapshot(({ tmp, snapshot, before }) =>
340    Effect.gen(function* () {
341      yield* mkdirp(`${tmp.path}/目录/подкаталог`)
342      const deepFile = fwd(tmp.path, "目录", "подкаталог", "文件.txt")
343      yield* write(deepFile, "deep unicode content")
344      const patch = yield* snapshot.patch(before)
345      expect(patch.files).toContain(deepFile)
346      yield* snapshot.revert([patch])
347      expect(yield* exists(deepFile)).toBe(false)
348    }),
349  ),
350  { git: true },
351)
352 
353it.instance(
354  "very long filenames",
355  withTrackedSnapshot(({ tmp, snapshot, before }) =>
356    Effect.gen(function* () {
357      const longFile = fwd(tmp.path, `${"a".repeat(200)}.txt`)
358      yield* write(longFile, "long filename content")
359      const patch = yield* snapshot.patch(before)
360      expect(patch.files).toContain(longFile)
361      yield* snapshot.revert([patch])
362      expect(yield* exists(longFile)).toBe(false)
363    }),
364  ),
365  { git: true },
366)
367 
368it.instance(
369  "hidden files",
370  withTrackedSnapshot(({ tmp, snapshot, before }) =>
371    Effect.gen(function* () {
372      yield* write(`${tmp.path}/.hidden`, "hidden content")
373      yield* write(`${tmp.path}/.gitignore`, "*.log")
374      yield* write(`${tmp.path}/.config`, "config content")
375      const patch = yield* snapshot.patch(before)
376      expect(patch.files).toContain(fwd(tmp.path, ".hidden"))
377      expect(patch.files).toContain(fwd(tmp.path, ".gitignore"))
378      expect(patch.files).toContain(fwd(tmp.path, ".config"))
379    }),
380  ),
381  { git: true },
382)
383 
384it.instance(
385  "nested symlinks",
386  withTrackedSnapshot(({ tmp, snapshot, before }) =>
387    Effect.gen(function* () {
388      yield* mkdirp(`${tmp.path}/sub/dir`)
389      yield* write(`${tmp.path}/sub/dir/target.txt`, "target content")
390      yield* Effect.promise(() => fs.symlink(`${tmp.path}/sub/dir/target.txt`, `${tmp.path}/sub/dir/link.txt`, "file"))
391      yield* Effect.promise(() => fs.symlink(`${tmp.path}/sub`, `${tmp.path}/sub-link`, "dir"))
392      const patch = yield* snapshot.patch(before)
393      expect(patch.files).toContain(fwd(tmp.path, "sub", "dir", "link.txt"))
394      expect(patch.files).toContain(fwd(tmp.path, "sub-link"))
395    }),
396  ),
397  { git: true },
398)
399 
400it.instance(
401  "file permissions and ownership changes",
402  withTrackedSnapshot(({ tmp, snapshot, before }) =>
403    Effect.gen(function* () {
404      yield* Effect.promise(() => fs.chmod(`${tmp.path}/a.txt`, 0o600))
405      yield* Effect.promise(() => fs.chmod(`${tmp.path}/a.txt`, 0o755))
406      yield* Effect.promise(() => fs.chmod(`${tmp.path}/a.txt`, 0o644))
407      expect((yield* snapshot.patch(before)).files.length).toBe(0)
408    }),
409  ),
410  { git: true },
411)
412 
413it.instance(
414  "circular symlinks",
415  withTrackedSnapshot(({ tmp, snapshot, before }) =>
416    Effect.gen(function* () {
417      yield* Effect.promise(() =>
418        fs.symlink(`${tmp.path}/circular`, `${tmp.path}/circular`, "dir").catch(() => undefined),
419      )
420      expect((yield* snapshot.patch(before)).files.length).toBeGreaterThanOrEqual(0)
421    }),
422  ),
423  { git: true },
424)
425 
426it.live(
427  "source project gitignore is respected - ignored files are not snapshotted",
428  Effect.gen(function* () {
429    const dir = yield* scopedGitTmpdir()
430    yield* write(`${dir}/.gitignore`, "*.ignored\nbuild/\nnode_modules/\n")
431    yield* write(`${dir}/tracked.txt`, "tracked content")
432    yield* write(`${dir}/ignored.ignored`, "ignored content")
433    yield* mkdirp(`${dir}/build`)
434    yield* write(`${dir}/build/output.js`, "build output")
435    yield* write(`${dir}/normal.js`, "normal js")
436    yield* exec(dir, ["git", "add", "."])
437    yield* exec(dir, ["git", "commit", "-m", "init"])
438    yield* Effect.gen(function* () {
439      const snapshot = yield* Snapshot.Service
440      const before = yield* snapshot.track()
441      expect(before).toBeTruthy()
442      yield* write(`${dir}/tracked.txt`, "modified tracked")
443      yield* write(`${dir}/new.ignored`, "new ignored")
444      yield* write(`${dir}/new-tracked.txt`, "new tracked")
445      yield* write(`${dir}/build/new-build.js`, "new build file")
446      const patch = yield* snapshot.patch(before!)
447      expect(patch.files).toContain(fwd(dir, "new-tracked.txt"))
448      expect(patch.files).toContain(fwd(dir, "tracked.txt"))
449      expect(patch.files).not.toContain(fwd(dir, "new.ignored"))
450      expect(patch.files).not.toContain(fwd(dir, "ignored.ignored"))
451      expect(patch.files).not.toContain(fwd(dir, "build/output.js"))
452      expect(patch.files).not.toContain(fwd(dir, "build/new-build.js"))
453    }).pipe(provideInstance(dir))
454  }),
455)
456 
457it.live(
458  "subdirectory snapshots include scoped changes only",
459  Effect.gen(function* () {
460    const dir = yield* scopedGitTmpdir()
461    const frontend = path.join(dir, "frontend")
462    yield* write(`${frontend}/tracked.txt`, "initial")
463    yield* write(`${frontend}/deleted.txt`, "initial")
464    yield* write(`${dir}/backend/tracked.txt`, "initial")
465    yield* write(`${dir}/backend/deleted.txt`, "initial")
466    yield* exec(dir, ["git", "add", "."])
467    yield* exec(dir, ["git", "commit", "-m", "init"])
468    yield* Effect.gen(function* () {
469      const snapshot = yield* Snapshot.Service
470      const before = yield* snapshot.track()
471      expect(before).toBeTruthy()
472      yield* write(`${frontend}/tracked.txt`, "changed")
473      yield* write(`${frontend}/untracked.txt`, "new")
474      yield* rm(`${frontend}/deleted.txt`)
475      yield* write(`${dir}/backend/tracked.txt`, "changed")
476      yield* rm(`${dir}/backend/deleted.txt`)
477      const patch = yield* snapshot.patch(before!)
478      const diff = yield* snapshot.diff(before!)
479      expect(patch.files).toContain(fwd(frontend, "tracked.txt"))
480      expect(patch.files).toContain(fwd(frontend, "untracked.txt"))
481      expect(patch.files).toContain(fwd(frontend, "deleted.txt"))
482      expect(patch.files).not.toContain(fwd(dir, "backend", "tracked.txt"))
483      expect(patch.files).not.toContain(fwd(dir, "backend", "deleted.txt"))
484      expect(diff).not.toContain("backend/tracked.txt")
485      expect(diff).not.toContain("backend/deleted.txt")
486    }).pipe(provideInstance(frontend))
487  }),
488)
489 
490nonWindowsIt(
491  "subdirectory snapshots treat wildcard characters literally",
492  Effect.gen(function* () {
493    const dir = yield* scopedGitTmpdir()
494    const subdir = path.join(dir, "src*")
495    yield* write(`${subdir}/file.txt`, "initial")
496    yield* write(`${subdir}/later-ignored.txt`, "initial")
497    yield* write(`${dir}/srca/file.txt`, "initial")
498    yield* exec(dir, ["git", "add", "."])
499    yield* exec(dir, ["git", "commit", "-m", "init"])
500    yield* Effect.gen(function* () {
501      const snapshot = yield* Snapshot.Service
502      const before = yield* snapshot.track()
503      expect(before).toBeTruthy()
504      yield* write(`${subdir}/file.txt`, "changed")
505      yield* write(`${subdir}/later-ignored.txt`, "changed")
506      yield* write(`${subdir}/.gitignore`, "later-ignored.txt\n")
507      yield* write(`${dir}/srca/file.txt`, "changed")
508      const patch = yield* snapshot.patch(before!)
509      const diff = yield* snapshot.diff(before!)
510      expect(patch.files).toContain(fwd(subdir, "file.txt"))
511      expect(patch.files).toContain(fwd(subdir, ".gitignore"))
512      expect(patch.files).not.toContain(fwd(subdir, "later-ignored.txt"))
513      expect(patch.files).not.toContain(fwd(dir, "srca", "file.txt"))
514      expect(diff).toContain("src*/later-ignored.txt")
515      expect(diff).toContain("deleted file mode")
516      expect(diff).not.toContain("srca/file.txt")
517    }).pipe(provideInstance(subdir))
518  }),
519)
520 
521nonWindowsIt(
522  "subdirectory snapshots treat leading colons literally",
523  Effect.gen(function* () {
524    const dir = yield* scopedGitTmpdir()
525    const subdir = path.join(dir, ":src")
526    yield* write(`${subdir}/kept.txt`, "initial")
527    yield* write(`${subdir}/later-ignored.txt`, "initial")
528    yield* exec(dir, ["git", "add", "."])
529    yield* exec(dir, ["git", "commit", "-m", "init"])
530    yield* Effect.gen(function* () {
531      const snapshot = yield* Snapshot.Service
532      const before = yield* snapshot.track()
533      expect(before).toBeTruthy()
534      yield* write(`${subdir}/kept.txt`, "changed")
535      yield* write(`${subdir}/later-ignored.txt`, "changed")
536      yield* write(`${subdir}/.gitignore`, "later-ignored.txt\n")
537      const patch = yield* snapshot.patch(before!)
538      const diff = yield* snapshot.diff(before!)
539      expect(patch.files).toContain(fwd(subdir, "kept.txt"))
540      expect(patch.files).toContain(fwd(subdir, ".gitignore"))
541      expect(patch.files).not.toContain(fwd(subdir, "later-ignored.txt"))
542      expect(diff).toContain(":src/later-ignored.txt")
543      expect(diff).toContain("deleted file mode")
544    }).pipe(provideInstance(subdir))
545  }),
546)
547 
548it.instance(
549  "gitignore changes",
550  withTrackedSnapshot(({ tmp, snapshot, before }) =>
551    Effect.gen(function* () {
552      yield* write(`${tmp.path}/.gitignore`, "*.ignored")
553      yield* write(`${tmp.path}/test.ignored`, "ignored content")
554      yield* write(`${tmp.path}/normal.txt`, "normal content")
555      const patch = yield* snapshot.patch(before)
556      expect(patch.files).toContain(fwd(tmp.path, ".gitignore"))
557      expect(patch.files).toContain(fwd(tmp.path, "normal.txt"))
558      expect(patch.files).not.toContain(fwd(tmp.path, "test.ignored"))
559    }),
560  ),
561  { git: true },
562)
563 
564it.instance(
565  "files tracked in snapshot but now gitignored are filtered out",
566  Effect.gen(function* () {
567    const tmp = yield* bootstrap()
568    const snapshot = yield* Snapshot.Service
569    yield* write(`${tmp.path}/later-ignored.txt`, "initial content")
570    const before = yield* snapshot.track()
571    expect(before).toBeTruthy()
572    yield* write(`${tmp.path}/later-ignored.txt`, "modified content")
573    yield* write(`${tmp.path}/.gitignore`, "later-ignored.txt\n")
574    yield* write(`${tmp.path}/still-tracked.txt`, "new tracked file")
575    const patch = yield* snapshot.patch(before!)
576    expect(patch.files).not.toContain(fwd(tmp.path, "later-ignored.txt"))
577    expect(patch.files).toContain(fwd(tmp.path, ".gitignore"))
578    expect(patch.files).toContain(fwd(tmp.path, "still-tracked.txt"))
579  }),
580  { git: true },
581)
582 
583it.instance(
584  "gitignore updated between track calls filters from diff",
585  withTrackedSnapshot(({ tmp, snapshot, before }) =>
586    Effect.gen(function* () {
587      yield* write(`${tmp.path}/a.txt`, "modified content")
588      yield* write(`${tmp.path}/.gitignore`, "a.txt\n")
589      yield* write(`${tmp.path}/b.txt`, "also modified")
590      const after = yield* snapshot.track()
591      expect(after).toBeTruthy()
592      const diffs = yield* snapshot.diffFull(before, after!)
593      expect(diffs.some((x) => x.file === "a.txt")).toBe(false)
594      expect(diffs.some((x) => x.file === ".gitignore")).toBe(true)
595      expect(diffs.some((x) => x.file === "b.txt")).toBe(true)
596    }),
597  ),
598  { git: true },
599)
600 
601it.instance(
602  "git info exclude changes",
603  withTrackedSnapshot(({ tmp, snapshot, before }) =>
604    Effect.gen(function* () {
605      const file = `${tmp.path}/.git/info/exclude`
606      yield* write(file, `${(yield* Effect.promise(() => Bun.file(file).text())).trimEnd()}\nignored.txt\n`)
607      yield* write(`${tmp.path}/ignored.txt`, "ignored content")
608      yield* write(`${tmp.path}/normal.txt`, "normal content")
609      const patch = yield* snapshot.patch(before)
610      expect(patch.files).toContain(fwd(tmp.path, "normal.txt"))
611      expect(patch.files).not.toContain(fwd(tmp.path, "ignored.txt"))
612      const after = yield* snapshot.track()
613      const diffs = yield* snapshot.diffFull(before, after!)
614      expect(diffs.some((x) => x.file === "normal.txt")).toBe(true)
615      expect(diffs.some((x) => x.file === "ignored.txt")).toBe(false)
616    }),
617  ),
618  { git: true },
619)
620 
621it.instance(
622  "git info exclude keeps global excludes",
623  Effect.gen(function* () {
624    const tmp = yield* bootstrap()
625    const global = `${tmp.path}/global.ignore`
626    const config = `${tmp.path}/global.gitconfig`
627    yield* write(global, "global.tmp\n")
628    yield* write(config, `[core]\n\texcludesFile = ${global.replaceAll("\\", "/")}\n`)
629    yield* withGitConfigGlobal(
630      config,
631      Effect.gen(function* () {
632        const snapshot = yield* Snapshot.Service
633        const before = yield* snapshot.track()
634        expect(before).toBeTruthy()
635        const file = `${tmp.path}/.git/info/exclude`
636        yield* write(file, `${(yield* Effect.promise(() => Bun.file(file).text())).trimEnd()}\ninfo.tmp\n`)
637        yield* write(`${tmp.path}/global.tmp`, "global content")
638        yield* write(`${tmp.path}/info.tmp`, "info content")
639        yield* write(`${tmp.path}/normal.txt`, "normal content")
640        const patch = yield* snapshot.patch(before!)
641        expect(patch.files).toContain(fwd(tmp.path, "normal.txt"))
642        expect(patch.files).not.toContain(fwd(tmp.path, "global.tmp"))
643        expect(patch.files).not.toContain(fwd(tmp.path, "info.tmp"))
644      }),
645    )
646  }),
647  { git: true },
648)
649 
650it.instance(
651  "concurrent file operations during patch",
652  withTrackedSnapshot(({ tmp, snapshot, before }) =>
653    Effect.gen(function* () {
654      const fiber = yield* Effect.gen(function* () {
655        for (let i = 0; i < 10; i++) {
656          yield* write(`${tmp.path}/concurrent${i}.txt`, `concurrent${i}`)
657          yield* Effect.sleep("1 millis")
658        }
659      }).pipe(Effect.forkScoped)
660      const patch = yield* snapshot.patch(before)
661      yield* Fiber.join(fiber)
662      expect(patch.files.length).toBeGreaterThanOrEqual(0)
663    }),
664  ),
665  { git: true },
666)
667 
668it.live(
669  "snapshot state isolation between projects",
670  Effect.gen(function* () {
671    const tmp1 = yield* bootstrapScoped()
672    const tmp2 = yield* bootstrapScoped()
673    yield* Effect.gen(function* () {
674      const snapshot = yield* Snapshot.Service
675      const before1 = yield* snapshot.track()
676      yield* write(`${tmp1.path}/project1.txt`, "project1 content")
677      const patch1 = yield* snapshot.patch(before1!)
678      expect(patch1.files).toContain(fwd(tmp1.path, "project1.txt"))
679    }).pipe(provideInstance(tmp1.path))
680    yield* Effect.gen(function* () {
681      const snapshot = yield* Snapshot.Service
682      const before2 = yield* snapshot.track()
683      yield* write(`${tmp2.path}/project2.txt`, "project2 content")
684      const patch2 = yield* snapshot.patch(before2!)
685      expect(patch2.files).toContain(fwd(tmp2.path, "project2.txt"))
686      expect(patch2.files).not.toContain(fwd(tmp1.path, "project1.txt"))
687    }).pipe(provideInstance(tmp2.path))
688  }),
689)
690 
691it.live(
692  "patch detects changes in secondary worktree",
693  Effect.gen(function* () {
694    const tmp = yield* bootstrapScoped()
695    const worktreePath = `${tmp.path}-worktree`
696    yield* exec(tmp.path, ["git", "worktree", "add", worktreePath, "HEAD"])
697    yield* Effect.addFinalizer(() => cleanupWorktree(tmp.path, worktreePath))
698    yield* Effect.gen(function* () {
699      const snapshot = yield* Snapshot.Service
700      expect(yield* snapshot.track()).toBeTruthy()
701    }).pipe(provideInstance(tmp.path))
702    yield* Effect.gen(function* () {
703      const snapshot = yield* Snapshot.Service
704      const before = yield* snapshot.track()
705      expect(before).toBeTruthy()
706      const worktreeFile = fwd(worktreePath, "worktree.txt")
707      yield* write(worktreeFile, "worktree content")
708      expect((yield* snapshot.patch(before!)).files).toContain(worktreeFile)
709    }).pipe(provideInstance(worktreePath))
710  }),
711)
712 
713it.live(
714  "revert only removes files in invoking worktree",
715  Effect.gen(function* () {
716    const tmp = yield* bootstrapScoped()
717    const worktreePath = `${tmp.path}-worktree`
718    const primaryFile = `${tmp.path}/worktree.txt`
719    yield* exec(tmp.path, ["git", "worktree", "add", worktreePath, "HEAD"])
720    yield* Effect.addFinalizer(() => cleanupWorktree(tmp.path, worktreePath, [primaryFile]))
721    yield* Effect.gen(function* () {
722      const snapshot = yield* Snapshot.Service
723      expect(yield* snapshot.track()).toBeTruthy()
724    }).pipe(provideInstance(tmp.path))
725    yield* write(primaryFile, "primary content")
726    yield* Effect.gen(function* () {
727      const snapshot = yield* Snapshot.Service
728      const before = yield* snapshot.track()
729      expect(before).toBeTruthy()
730      const worktreeFile = fwd(worktreePath, "worktree.txt")
731      yield* write(worktreeFile, "worktree content")
732      const patch = yield* snapshot.patch(before!)
733      yield* snapshot.revert([patch])
734      expect(yield* exists(worktreeFile)).toBe(false)
735    }).pipe(provideInstance(worktreePath))
736    expect(yield* readText(primaryFile)).toBe("primary content")
737  }),
738)
739 
740it.live(
741  "diff reports worktree-only/shared edits and ignores primary-only",
742  Effect.gen(function* () {
743    const tmp = yield* bootstrapScoped()
744    const worktreePath = `${tmp.path}-worktree`
745    yield* exec(tmp.path, ["git", "worktree", "add", worktreePath, "HEAD"])
746    yield* Effect.addFinalizer(() =>
747      cleanupWorktree(tmp.path, worktreePath, [`${tmp.path}/shared.txt`, `${tmp.path}/primary-only.txt`]),
748    )
749    yield* Effect.gen(function* () {
750      const snapshot = yield* Snapshot.Service
751      expect(yield* snapshot.track()).toBeTruthy()
752    }).pipe(provideInstance(tmp.path))
753    yield* Effect.gen(function* () {
754      const snapshot = yield* Snapshot.Service
755      const before = yield* snapshot.track()
756      expect(before).toBeTruthy()
757      yield* write(`${worktreePath}/worktree-only.txt`, "worktree diff content")
758      yield* write(`${worktreePath}/shared.txt`, "worktree edit")
759      yield* write(`${tmp.path}/shared.txt`, "primary edit")
760      yield* write(`${tmp.path}/primary-only.txt`, "primary change")
761      const diff = yield* snapshot.diff(before!)
762      expect(diff).toContain("worktree-only.txt")
763      expect(diff).toContain("shared.txt")
764      expect(diff).not.toContain("primary-only.txt")
765    }).pipe(provideInstance(worktreePath))
766  }),
767)
768 
769it.instance(
770  "track with no changes returns same hash",
771  withTrackedSnapshot(({ snapshot, before }) =>
772    Effect.gen(function* () {
773      expect(yield* snapshot.track()).toBe(before)
774      expect(yield* snapshot.track()).toBe(before)
775    }),
776  ),
777  { git: true },
778)
779 
780it.instance(
781  "diff function with various changes",
782  withTrackedSnapshot(({ tmp, snapshot, before }) =>
783    Effect.gen(function* () {
784      yield* rm(`${tmp.path}/a.txt`)
785      yield* write(`${tmp.path}/new.txt`, "new content")
786      yield* write(`${tmp.path}/b.txt`, "modified content")
787      const diff = yield* snapshot.diff(before)
788      expect(diff).toContain("a.txt")
789      expect(diff).toContain("b.txt")
790      expect(diff).toContain("new.txt")
791    }),
792  ),
793  { git: true },
794)
795 
796it.instance(
797  "restore function",
798  withTrackedSnapshot(({ tmp, snapshot, before }) =>
799    Effect.gen(function* () {
800      yield* rm(`${tmp.path}/a.txt`)
801      yield* write(`${tmp.path}/new.txt`, "new content")
802      yield* write(`${tmp.path}/b.txt`, "modified")
803      yield* snapshot.restore(before)
804      expect(yield* exists(`${tmp.path}/a.txt`)).toBe(true)
805      expect(yield* readText(`${tmp.path}/a.txt`)).toBe(tmp.extra.aContent)
806      expect(yield* exists(`${tmp.path}/new.txt`)).toBe(true)
807      expect(yield* readText(`${tmp.path}/b.txt`)).toBe(tmp.extra.bContent)
808    }),
809  ),
810  { git: true },
811)
812 
813it.instance(
814  "revert should not delete files that existed but were deleted in snapshot",
815  Effect.gen(function* () {
816    const tmp = yield* bootstrap()
817    const snapshot = yield* Snapshot.Service
818    const snapshot1 = yield* snapshot.track()
819    expect(snapshot1).toBeTruthy()
820    yield* rm(`${tmp.path}/a.txt`)
821    const snapshot2 = yield* snapshot.track()
822    expect(snapshot2).toBeTruthy()
823    yield* write(`${tmp.path}/a.txt`, "recreated content")
824    const patch = yield* snapshot.patch(snapshot2!)
825    expect(patch.files).toContain(fwd(tmp.path, "a.txt"))
826    yield* snapshot.revert([patch])
827    expect(yield* exists(`${tmp.path}/a.txt`)).toBe(false)
828  }),
829  { git: true },
830)
831 
832it.instance(
833  "revert preserves file that existed in snapshot when deleted then recreated",
834  Effect.gen(function* () {
835    const tmp = yield* bootstrap()
836    const snapshot = yield* Snapshot.Service
837    yield* write(`${tmp.path}/existing.txt`, "original content")
838    const hash = yield* snapshot.track()
839    expect(hash).toBeTruthy()
840    yield* rm(`${tmp.path}/existing.txt`)
841    yield* write(`${tmp.path}/existing.txt`, "recreated")
842    yield* write(`${tmp.path}/newfile.txt`, "new")
843    const patch = yield* snapshot.patch(hash!)
844    expect(patch.files).toContain(fwd(tmp.path, "existing.txt"))
845    expect(patch.files).toContain(fwd(tmp.path, "newfile.txt"))
846    yield* snapshot.revert([patch])
847    expect(yield* exists(`${tmp.path}/newfile.txt`)).toBe(false)
848    expect(yield* exists(`${tmp.path}/existing.txt`)).toBe(true)
849    expect(yield* readText(`${tmp.path}/existing.txt`)).toBe("original content")
850  }),
851  { git: true },
852)
853 
854it.instance(
855  "diffFull sets status based on git change type",
856  Effect.gen(function* () {
857    const tmp = yield* bootstrap()
858    const snapshot = yield* Snapshot.Service
859    yield* write(`${tmp.path}/grow.txt`, "one\n")
860    yield* write(`${tmp.path}/trim.txt`, "line1\nline2\n")
861    yield* write(`${tmp.path}/delete.txt`, "gone")
862    const before = yield* snapshot.track()
863    expect(before).toBeTruthy()
864    yield* write(`${tmp.path}/grow.txt`, "one\ntwo\n")
865    yield* write(`${tmp.path}/trim.txt`, "line1\n")
866    yield* rm(`${tmp.path}/delete.txt`)
867    yield* write(`${tmp.path}/added.txt`, "new")
868    const after = yield* snapshot.track()
869    expect(after).toBeTruthy()
870    const diffs = yield* snapshot.diffFull(before!, after!)
871    expect(diffs.length).toBe(4)
872    expect(diffs.find((d) => d.file === "added.txt")!.status).toBe("added")
873    expect(diffs.find((d) => d.file === "delete.txt")!.status).toBe("deleted")
874    const grow = diffs.find((d) => d.file === "grow.txt")!
875    expect(grow.status).toBe("modified")
876    expect(grow.additions).toBeGreaterThan(0)
877    expect(grow.deletions).toBe(0)
878    const trim = diffs.find((d) => d.file === "trim.txt")!
879    expect(trim.status).toBe("modified")
880    expect(trim.additions).toBe(0)
881    expect(trim.deletions).toBeGreaterThan(0)
882  }),
883  { git: true },
884)
885 
886it.instance(
887  "diffFull with new file additions",
888  withTrackedSnapshot(({ tmp, snapshot, before }) =>
889    Effect.gen(function* () {
890      yield* write(`${tmp.path}/new.txt`, "new content")
891      const after = yield* snapshot.track()
892      expect(after).toBeTruthy()
893      const diffs = yield* snapshot.diffFull(before, after!)
894      expect(diffs.length).toBe(1)
895      expect(diffs[0].file).toBe("new.txt")
896      expect(diffs[0].patch).toContain("+new content")
897      expect(diffs[0].additions).toBe(1)
898      expect(diffs[0].deletions).toBe(0)
899    }),
900  ),
901  { git: true },
902)
903 
904it.instance(
905  "diffFull with a large interleaved mixed diff",
906  Effect.gen(function* () {
907    const tmp = yield* bootstrap()
908    const snapshot = yield* Snapshot.Service
909    const ids = Array.from({ length: MIXED_BATCH_GROUP_COUNT }, (_, i) => i.toString().padStart(3, "0"))
910    const mod = ids.map((id) => fwd(tmp.path, "mix", `${id}-mod.txt`))
911    const del = ids.map((id) => fwd(tmp.path, "mix", `${id}-del.txt`))
912    const add = ids.map((id) => fwd(tmp.path, "mix", `${id}-add.txt`))
913    const bin = ids.map((id) => fwd(tmp.path, "mix", `${id}-bin.bin`))
914    yield* mkdirp(`${tmp.path}/mix`)
915    yield* Effect.all(
916      [
917        ...mod.map((file, i) => write(file, `before-${ids[i]}-é\n🙂\nline`)),
918        ...del.map((file, i) => write(file, `gone-${ids[i]}\n你好`)),
919        ...bin.map((file, i) => write(file, new Uint8Array([0, i, 255, i % 251]))),
920      ],
921      { concurrency: "unbounded" },
922    )
923    const before = yield* snapshot.track()
924    expect(before).toBeTruthy()
925    yield* Effect.all(
926      [
927        ...mod.map((file, i) => write(file, `after-${ids[i]}-é\n🚀\nline`)),
928        ...add.map((file, i) => write(file, `new-${ids[i]}\nこんにちは`)),
929        ...bin.map((file, i) => write(file, new Uint8Array([9, i, 8, i % 251]))),
930        ...del.map((file) => rm(file)),
931      ],
932      { concurrency: "unbounded" },
933    )
934    const after = yield* snapshot.track()
935    expect(after).toBeTruthy()
936    const diffs = yield* snapshot.diffFull(before!, after!)
937    expect(diffs).toHaveLength(ids.length * 4)
938    const map = new Map(diffs.map((item) => [item.file, item]))
939    for (let i = 0; i < ids.length; i++) {
940      const m = map.get(fwd("mix", `${ids[i]}-mod.txt`))
941      expect(m).toBeDefined()
942      expect(m!.patch).toContain(`-before-${ids[i]}-é`)
943      expect(m!.patch).toContain(`+after-${ids[i]}-é`)
944      expect(m!.status).toBe("modified")
945      const d = map.get(fwd("mix", `${ids[i]}-del.txt`))
946      expect(d).toBeDefined()
947      expect(d!.patch).toContain(`-gone-${ids[i]}`)
948      expect(d!.status).toBe("deleted")
949      const a = map.get(fwd("mix", `${ids[i]}-add.txt`))
950      expect(a).toBeDefined()
951      expect(a!.patch).toContain(`+new-${ids[i]}`)
952      expect(a!.status).toBe("added")
953      const b = map.get(fwd("mix", `${ids[i]}-bin.bin`))
954      expect(b).toBeDefined()
955      expect(b!.patch).toBe("")
956      expect(b!.additions).toBe(0)
957      expect(b!.deletions).toBe(0)
958      expect(b!.status).toBe("modified")
959    }
960  }),
961  { git: true },
962)
963 
964it.instance(
965  "diffFull preserves git diff order across batch boundaries",
966  Effect.gen(function* () {
967    const tmp = yield* bootstrap()
968    const snapshot = yield* Snapshot.Service
969    const ids = Array.from({ length: OVER_BATCH_COUNT }, (_, i) => i.toString().padStart(3, "0"))
970    yield* mkdirp(`${tmp.path}/order`)
971    yield* Effect.all(
972      ids.map((id) => write(`${tmp.path}/order/${id}.txt`, `before-${id}`)),
973      { concurrency: "unbounded" },
974    )
975    const before = yield* snapshot.track()
976    expect(before).toBeTruthy()
977    yield* Effect.all(
978      ids.map((id) => write(`${tmp.path}/order/${id}.txt`, `after-${id}`)),
979      { concurrency: "unbounded" },
980    )
981    const after = yield* snapshot.track()
982    expect(after).toBeTruthy()
983    expect((yield* snapshot.diffFull(before!, after!)).map((item) => item.file)).toEqual(
984      ids.map((id) => `order/${id}.txt`),
985    )
986  }),
987  { git: true },
988)
989 
990it.instance(
991  "diffFull with file modifications",
992  withTrackedSnapshot(({ tmp, snapshot, before }) =>
993    Effect.gen(function* () {
994      yield* write(`${tmp.path}/b.txt`, "modified content")
995      const after = yield* snapshot.track()
996      expect(after).toBeTruthy()
997      const diffs = yield* snapshot.diffFull(before, after!)
998      expect(diffs.length).toBe(1)
999      expect(diffs[0].file).toBe("b.txt")
1000      expect(diffs[0].patch).toContain(`-${tmp.extra.bContent}`)
1001      expect(diffs[0].patch).toContain("+modified content")
1002      expect(diffs[0].additions).toBeGreaterThan(0)
1003      expect(diffs[0].deletions).toBeGreaterThan(0)
1004    }),
1005  ),
1006  { git: true },
1007)
1008 
1009it.instance(
1010  "diffFull with file deletions",
1011  withTrackedSnapshot(({ tmp, snapshot, before }) =>
1012    Effect.gen(function* () {
1013      yield* rm(`${tmp.path}/a.txt`)
1014      const after = yield* snapshot.track()
1015      expect(after).toBeTruthy()
1016      const diffs = yield* snapshot.diffFull(before, after!)
1017      expect(diffs.length).toBe(1)
1018      expect(diffs[0].file).toBe("a.txt")
1019      expect(diffs[0].patch).toContain(`-${tmp.extra.aContent}`)
1020      expect(diffs[0].additions).toBe(0)
1021      expect(diffs[0].deletions).toBe(1)
1022    }),
1023  ),
1024  { git: true },
1025)
1026 
1027it.instance(
1028  "diffFull with multiple line additions",
1029  withTrackedSnapshot(({ tmp, snapshot, before }) =>
1030    Effect.gen(function* () {
1031      yield* write(`${tmp.path}/multi.txt`, "line1\nline2\nline3")
1032      const after = yield* snapshot.track()
1033      expect(after).toBeTruthy()
1034      const diffs = yield* snapshot.diffFull(before, after!)
1035      expect(diffs.length).toBe(1)
1036      expect(diffs[0].file).toBe("multi.txt")
1037      expect(diffs[0].patch).toContain("+line1")
1038      expect(diffs[0].patch).toContain("+line3")
1039      expect(diffs[0].additions).toBe(3)
1040      expect(diffs[0].deletions).toBe(0)
1041    }),
1042  ),
1043  { git: true },
1044)
1045 
1046it.instance(
1047  "diffFull with addition and deletion",
1048  withTrackedSnapshot(({ tmp, snapshot, before }) =>
1049    Effect.gen(function* () {
1050      yield* write(`${tmp.path}/added.txt`, "added content")
1051      yield* rm(`${tmp.path}/a.txt`)
1052      const after = yield* snapshot.track()
1053      expect(after).toBeTruthy()
1054      const diffs = yield* snapshot.diffFull(before, after!)
1055      expect(diffs.length).toBe(2)
1056      const added = diffs.find((d) => d.file === "added.txt")!
1057      expect(added.patch).toContain("+added content")
1058      expect(added.additions).toBe(1)
1059      expect(added.deletions).toBe(0)
1060      const removed = diffs.find((d) => d.file === "a.txt")!
1061      expect(removed.patch).toContain(`-${tmp.extra.aContent}`)
1062      expect(removed.additions).toBe(0)
1063      expect(removed.deletions).toBe(1)
1064    }),
1065  ),
1066  { git: true },
1067)
1068 
1069it.instance(
1070  "diffFull with multiple additions and deletions",
1071  withTrackedSnapshot(({ tmp, snapshot, before }) =>
1072    Effect.gen(function* () {
1073      yield* write(`${tmp.path}/multi1.txt`, "line1\nline2\nline3")
1074      yield* write(`${tmp.path}/multi2.txt`, "single line")
1075      yield* rm(`${tmp.path}/a.txt`)
1076      yield* rm(`${tmp.path}/b.txt`)
1077      const after = yield* snapshot.track()
1078      expect(after).toBeTruthy()
1079      const diffs = yield* snapshot.diffFull(before, after!)
1080      expect(diffs.length).toBe(4)
1081      expect(diffs.find((d) => d.file === "multi1.txt")!.additions).toBe(3)
1082      expect(diffs.find((d) => d.file === "multi1.txt")!.deletions).toBe(0)
1083      expect(diffs.find((d) => d.file === "multi2.txt")!.additions).toBe(1)
1084      expect(diffs.find((d) => d.file === "multi2.txt")!.deletions).toBe(0)
1085      expect(diffs.find((d) => d.file === "a.txt")!.additions).toBe(0)
1086      expect(diffs.find((d) => d.file === "a.txt")!.deletions).toBe(1)
1087      expect(diffs.find((d) => d.file === "b.txt")!.additions).toBe(0)
1088      expect(diffs.find((d) => d.file === "b.txt")!.deletions).toBe(1)
1089    }),
1090  ),
1091  { git: true },
1092)
1093 
1094it.instance(
1095  "diffFull with no changes",
1096  withTrackedSnapshot(({ snapshot, before }) =>
1097    Effect.gen(function* () {
1098      const after = yield* snapshot.track()
1099      expect(after).toBeTruthy()
1100      expect((yield* snapshot.diffFull(before, after!)).length).toBe(0)
1101    }),
1102  ),
1103  { git: true },
1104)
1105 
1106it.instance(
1107  "diffFull with binary file changes",
1108  withTrackedSnapshot(({ tmp, snapshot, before }) =>
1109    Effect.gen(function* () {
1110      yield* write(`${tmp.path}/binary.bin`, new Uint8Array([0x00, 0x01, 0x02, 0x03]))
1111      const after = yield* snapshot.track()
1112      expect(after).toBeTruthy()
1113      const diffs = yield* snapshot.diffFull(before, after!)
1114      expect(diffs.length).toBe(1)
1115      expect(diffs[0].file).toBe("binary.bin")
1116      expect(diffs[0].patch).toBe("")
1117    }),
1118  ),
1119  { git: true },
1120)
1121 
1122it.instance(
1123  "diffFull with whitespace changes",
1124  Effect.gen(function* () {
1125    const tmp = yield* bootstrap()
1126    const snapshot = yield* Snapshot.Service
1127    yield* write(`${tmp.path}/whitespace.txt`, "line1\nline2")
1128    const before = yield* snapshot.track()
1129    expect(before).toBeTruthy()
1130    yield* write(`${tmp.path}/whitespace.txt`, "line1\n\nline2\n")
1131    const after = yield* snapshot.track()
1132    expect(after).toBeTruthy()
1133    const diffs = yield* snapshot.diffFull(before!, after!)
1134    expect(diffs.length).toBe(1)
1135    expect(diffs[0].file).toBe("whitespace.txt")
1136    expect(diffs[0].additions).toBeGreaterThan(0)
1137  }),
1138  { git: true },
1139)
1140 
1141it.instance(
1142  "revert with overlapping files across patches uses first patch hash",
1143  Effect.gen(function* () {
1144    const tmp = yield* bootstrap()
1145    const snapshot = yield* Snapshot.Service
1146    yield* write(`${tmp.path}/shared.txt`, "v1")
1147    const snap1 = yield* snapshot.track()
1148    expect(snap1).toBeTruthy()
1149    yield* write(`${tmp.path}/shared.txt`, "v2")
1150    const snap2 = yield* snapshot.track()
1151    expect(snap2).toBeTruthy()
1152    yield* write(`${tmp.path}/shared.txt`, "v3")
1153    const patch1 = yield* snapshot.patch(snap1!)
1154    const patch2 = yield* snapshot.patch(snap2!)
1155    expect(patch1.files).toContain(fwd(tmp.path, "shared.txt"))
1156    expect(patch2.files).toContain(fwd(tmp.path, "shared.txt"))
1157    yield* snapshot.revert([patch1, patch2])
1158    expect(yield* readText(`${tmp.path}/shared.txt`)).toBe("v1")
1159  }),
1160  { git: true },
1161)
1162 
1163it.instance(
1164  "revert preserves patch order when the same hash appears again",
1165  Effect.gen(function* () {
1166    const tmp = yield* bootstrap()
1167    const snapshot = yield* Snapshot.Service
1168    yield* mkdirp(`${tmp.path}/foo`)
1169    yield* write(`${tmp.path}/foo/bar`, "v1")
1170    yield* write(`${tmp.path}/a.txt`, "v1")
1171    const snap1 = yield* snapshot.track()
1172    expect(snap1).toBeTruthy()
1173    yield* rm(`${tmp.path}/foo`)
1174    yield* write(`${tmp.path}/foo`, "v2")
1175    yield* write(`${tmp.path}/a.txt`, "v2")
1176    const snap2 = yield* snapshot.track()
1177    expect(snap2).toBeTruthy()
1178    yield* rm(`${tmp.path}/foo`)
1179    yield* write(`${tmp.path}/a.txt`, "v3")
1180    yield* snapshot.revert([
1181      { hash: snap1!, files: [fwd(tmp.path, "a.txt")] },
1182      { hash: snap2!, files: [fwd(tmp.path, "foo")] },
1183      { hash: snap1!, files: [fwd(tmp.path, "foo", "bar")] },
1184    ])
1185    expect(yield* readText(`${tmp.path}/a.txt`)).toBe("v1")
1186    expect((yield* Effect.promise(() => fs.stat(`${tmp.path}/foo`))).isDirectory()).toBe(true)
1187    expect(yield* readText(`${tmp.path}/foo/bar`)).toBe("v1")
1188  }),
1189  { git: true },
1190)
1191 
1192it.instance(
1193  "revert handles large mixed batches across chunk boundaries",
1194  Effect.gen(function* () {
1195    const tmp = yield* bootstrap()
1196    const snapshot = yield* Snapshot.Service
1197    const base = Array.from({ length: OVER_BATCH_COUNT }, (_, i) => fwd(tmp.path, "batch", `${i}.txt`))
1198    const fresh = [fwd(tmp.path, "fresh", "0.txt")]
1199    yield* mkdirp(`${tmp.path}/batch`)
1200    yield* mkdirp(`${tmp.path}/fresh`)
1201    yield* Effect.all(
1202      base.map((file, i) => write(file, `base-${i}`)),
1203      { concurrency: "unbounded" },
1204    )
1205    const snap = yield* snapshot.track()
1206    expect(snap).toBeTruthy()
1207    yield* Effect.all(
1208      [...base.map((file, i) => write(file, `next-${i}`)), ...fresh.map((file, i) => write(file, `fresh-${i}`))],
1209      { concurrency: "unbounded" },
1210    )
1211    const patch = yield* snapshot.patch(snap!)
1212    expect(patch.files.length).toBe(base.length + fresh.length)
1213    yield* snapshot.revert([patch])
1214    for (let i = 0; i < base.length; i++) expect(yield* readText(base[i])).toBe(`base-${i}`)
1215    for (const file of fresh) expect(yield* exists(file)).toBe(false)
1216  }),
1217  { git: true },
1218)
1219