openAgent

1import { describe, test, expect } from "bun:test"
2import path from "path"
3import fs from "fs/promises"
4import { Filesystem } from "@/util/filesystem"
5import { tmpdir } from "../fixture/fixture"
6 
7describe("filesystem", () => {
8  describe("exists()", () => {
9    test("returns true for existing file", async () => {
10      await using tmp = await tmpdir()
11      const filepath = path.join(tmp.path, "test.txt")
12      await fs.writeFile(filepath, "content", "utf-8")
13 
14      expect(await Filesystem.exists(filepath)).toBe(true)
15    })
16 
17    test("returns false for non-existent file", async () => {
18      await using tmp = await tmpdir()
19      const filepath = path.join(tmp.path, "does-not-exist.txt")
20 
21      expect(await Filesystem.exists(filepath)).toBe(false)
22    })
23 
24    test("returns true for existing directory", async () => {
25      await using tmp = await tmpdir()
26      const dirpath = path.join(tmp.path, "subdir")
27      await fs.mkdir(dirpath)
28 
29      expect(await Filesystem.exists(dirpath)).toBe(true)
30    })
31  })
32 
33  describe("isDir()", () => {
34    test("returns true for directory", async () => {
35      await using tmp = await tmpdir()
36      const dirpath = path.join(tmp.path, "testdir")
37      await fs.mkdir(dirpath)
38 
39      expect(await Filesystem.isDir(dirpath)).toBe(true)
40    })
41 
42    test("returns false for file", async () => {
43      await using tmp = await tmpdir()
44      const filepath = path.join(tmp.path, "test.txt")
45      await fs.writeFile(filepath, "content", "utf-8")
46 
47      expect(await Filesystem.isDir(filepath)).toBe(false)
48    })
49 
50    test("returns false for non-existent path", async () => {
51      await using tmp = await tmpdir()
52      const filepath = path.join(tmp.path, "does-not-exist")
53 
54      expect(await Filesystem.isDir(filepath)).toBe(false)
55    })
56  })
57 
58  describe("size()", () => {
59    test("returns file size", async () => {
60      await using tmp = await tmpdir()
61      const filepath = path.join(tmp.path, "test.txt")
62      const content = "Hello, World!"
63      await fs.writeFile(filepath, content, "utf-8")
64 
65      expect(await Filesystem.size(filepath)).toBe(content.length)
66    })
67 
68    test("returns 0 for non-existent file", async () => {
69      await using tmp = await tmpdir()
70      const filepath = path.join(tmp.path, "does-not-exist.txt")
71 
72      expect(await Filesystem.size(filepath)).toBe(0)
73    })
74 
75    test("returns directory size", async () => {
76      await using tmp = await tmpdir()
77      const dirpath = path.join(tmp.path, "testdir")
78      await fs.mkdir(dirpath)
79 
80      // Directories have size on some systems
81      const size = await Filesystem.size(dirpath)
82      expect(typeof size).toBe("number")
83    })
84  })
85 
86  describe("findUp()", () => {
87    test("keeps previous nearest-first behavior for single target", async () => {
88      await using tmp = await tmpdir()
89      const parent = path.join(tmp.path, "parent")
90      const child = path.join(parent, "child")
91      await fs.mkdir(child, { recursive: true })
92      await fs.writeFile(path.join(tmp.path, "marker"), "root", "utf-8")
93      await fs.writeFile(path.join(parent, "marker"), "parent", "utf-8")
94 
95      const result = await Filesystem.findUp("marker", child, tmp.path)
96 
97      expect(result).toEqual([path.join(parent, "marker"), path.join(tmp.path, "marker")])
98    })
99 
100    test("respects stop boundary", async () => {
101      await using tmp = await tmpdir()
102      const parent = path.join(tmp.path, "parent")
103      const child = path.join(parent, "child")
104      await fs.mkdir(child, { recursive: true })
105      await fs.writeFile(path.join(tmp.path, "marker"), "root", "utf-8")
106      await fs.writeFile(path.join(parent, "marker"), "parent", "utf-8")
107 
108      const result = await Filesystem.findUp("marker", child, parent)
109 
110      expect(result).toEqual([path.join(parent, "marker")])
111    })
112 
113    test("supports multiple targets with nearest-first default ordering", async () => {
114      await using tmp = await tmpdir()
115      const parent = path.join(tmp.path, "parent")
116      const child = path.join(parent, "child")
117      await fs.mkdir(child, { recursive: true })
118 
119      await fs.writeFile(path.join(parent, "cfg.jsonc"), "{}", "utf-8")
120      await fs.writeFile(path.join(tmp.path, "cfg.json"), "{}", "utf-8")
121      await fs.writeFile(path.join(tmp.path, "cfg.jsonc"), "{}", "utf-8")
122 
123      const result = await Filesystem.findUp(["cfg.json", "cfg.jsonc"], child, tmp.path)
124 
125      expect(result).toEqual([
126        path.join(parent, "cfg.jsonc"),
127        path.join(tmp.path, "cfg.json"),
128        path.join(tmp.path, "cfg.jsonc"),
129      ])
130    })
131 
132    test("supports rootFirst ordering for multiple targets", async () => {
133      await using tmp = await tmpdir()
134      const parent = path.join(tmp.path, "parent")
135      const child = path.join(parent, "child")
136      await fs.mkdir(child, { recursive: true })
137 
138      await fs.writeFile(path.join(parent, "cfg.jsonc"), "{}", "utf-8")
139      await fs.writeFile(path.join(tmp.path, "cfg.json"), "{}", "utf-8")
140      await fs.writeFile(path.join(tmp.path, "cfg.jsonc"), "{}", "utf-8")
141 
142      const result = await Filesystem.findUp(["cfg.json", "cfg.jsonc"], child, tmp.path, { rootFirst: true })
143 
144      expect(result).toEqual([
145        path.join(tmp.path, "cfg.json"),
146        path.join(tmp.path, "cfg.jsonc"),
147        path.join(parent, "cfg.jsonc"),
148      ])
149    })
150 
151    test("rootFirst preserves json then jsonc order per directory", async () => {
152      await using tmp = await tmpdir()
153      const project = path.join(tmp.path, "project")
154      const nested = path.join(project, "nested")
155      await fs.mkdir(nested, { recursive: true })
156 
157      await fs.writeFile(path.join(tmp.path, "opencode.json"), "{}", "utf-8")
158      await fs.writeFile(path.join(tmp.path, "opencode.jsonc"), "{}", "utf-8")
159      await fs.writeFile(path.join(project, "opencode.json"), "{}", "utf-8")
160      await fs.writeFile(path.join(project, "opencode.jsonc"), "{}", "utf-8")
161 
162      const result = await Filesystem.findUp(["opencode.json", "opencode.jsonc"], nested, tmp.path, {
163        rootFirst: true,
164      })
165 
166      expect(result).toEqual([
167        path.join(tmp.path, "opencode.json"),
168        path.join(tmp.path, "opencode.jsonc"),
169        path.join(project, "opencode.json"),
170        path.join(project, "opencode.jsonc"),
171      ])
172    })
173  })
174 
175  describe("readText()", () => {
176    test("reads file content", async () => {
177      await using tmp = await tmpdir()
178      const filepath = path.join(tmp.path, "test.txt")
179      const content = "Hello, World!"
180      await fs.writeFile(filepath, content, "utf-8")
181 
182      expect(await Filesystem.readText(filepath)).toBe(content)
183    })
184 
185    test("throws for non-existent file", async () => {
186      await using tmp = await tmpdir()
187      const filepath = path.join(tmp.path, "does-not-exist.txt")
188 
189      await expect(Filesystem.readText(filepath)).rejects.toThrow()
190    })
191 
192    test("reads UTF-8 content correctly", async () => {
193      await using tmp = await tmpdir()
194      const filepath = path.join(tmp.path, "unicode.txt")
195      const content = "Hello 世界 🌍"
196      await fs.writeFile(filepath, content, "utf-8")
197 
198      expect(await Filesystem.readText(filepath)).toBe(content)
199    })
200  })
201 
202  describe("readJson()", () => {
203    test("reads and parses JSON", async () => {
204      await using tmp = await tmpdir()
205      const filepath = path.join(tmp.path, "test.json")
206      const data = { key: "value", nested: { array: [1, 2, 3] } }
207      await fs.writeFile(filepath, JSON.stringify(data), "utf-8")
208 
209      const result: typeof data = await Filesystem.readJson(filepath)
210      expect(result).toEqual(data)
211    })
212 
213    test("throws for invalid JSON", async () => {
214      await using tmp = await tmpdir()
215      const filepath = path.join(tmp.path, "invalid.json")
216      await fs.writeFile(filepath, "{ invalid json", "utf-8")
217 
218      await expect(Filesystem.readJson(filepath)).rejects.toThrow()
219    })
220 
221    test("throws for non-existent file", async () => {
222      await using tmp = await tmpdir()
223      const filepath = path.join(tmp.path, "does-not-exist.json")
224 
225      await expect(Filesystem.readJson(filepath)).rejects.toThrow()
226    })
227 
228    test("returns typed data", async () => {
229      await using tmp = await tmpdir()
230      const filepath = path.join(tmp.path, "typed.json")
231      interface Config {
232        name: string
233        version: number
234      }
235      const data: Config = { name: "test", version: 1 }
236      await fs.writeFile(filepath, JSON.stringify(data), "utf-8")
237 
238      const result = await Filesystem.readJson<Config>(filepath)
239      expect(result.name).toBe("test")
240      expect(result.version).toBe(1)
241    })
242  })
243 
244  describe("readBytes()", () => {
245    test("reads file as buffer", async () => {
246      await using tmp = await tmpdir()
247      const filepath = path.join(tmp.path, "test.txt")
248      const content = "Hello, World!"
249      await fs.writeFile(filepath, content, "utf-8")
250 
251      const buffer = await Filesystem.readBytes(filepath)
252      expect(buffer).toBeInstanceOf(Buffer)
253      expect(buffer.toString("utf-8")).toBe(content)
254    })
255 
256    test("throws for non-existent file", async () => {
257      await using tmp = await tmpdir()
258      const filepath = path.join(tmp.path, "does-not-exist.bin")
259 
260      await expect(Filesystem.readBytes(filepath)).rejects.toThrow()
261    })
262  })
263 
264  describe("write()", () => {
265    test("writes text content", async () => {
266      await using tmp = await tmpdir()
267      const filepath = path.join(tmp.path, "test.txt")
268      const content = "Hello, World!"
269 
270      await Filesystem.write(filepath, content)
271 
272      expect(await fs.readFile(filepath, "utf-8")).toBe(content)
273    })
274 
275    test("writes buffer content", async () => {
276      await using tmp = await tmpdir()
277      const filepath = path.join(tmp.path, "test.bin")
278      const content = Buffer.from([0x00, 0x01, 0x02, 0x03])
279 
280      await Filesystem.write(filepath, content)
281 
282      const read = await fs.readFile(filepath)
283      expect(read).toEqual(content)
284    })
285 
286    test("writes with permissions", async () => {
287      await using tmp = await tmpdir()
288      const filepath = path.join(tmp.path, "protected.txt")
289      const content = "secret"
290 
291      await Filesystem.write(filepath, content, 0o600)
292 
293      const stats = await fs.stat(filepath)
294      // Check permissions on Unix
295      if (process.platform !== "win32") {
296        expect(stats.mode & 0o777).toBe(0o600)
297      }
298    })
299 
300    test("creates parent directories", async () => {
301      await using tmp = await tmpdir()
302      const filepath = path.join(tmp.path, "nested", "deep", "file.txt")
303      const content = "nested content"
304 
305      await Filesystem.write(filepath, content)
306 
307      expect(await fs.readFile(filepath, "utf-8")).toBe(content)
308    })
309  })
310 
311  describe("writeJson()", () => {
312    test("writes JSON data", async () => {
313      await using tmp = await tmpdir()
314      const filepath = path.join(tmp.path, "data.json")
315      const data = { key: "value", number: 42 }
316 
317      await Filesystem.writeJson(filepath, data)
318 
319      const content = await fs.readFile(filepath, "utf-8")
320      expect(JSON.parse(content)).toEqual(data)
321    })
322 
323    test("writes formatted JSON", async () => {
324      await using tmp = await tmpdir()
325      const filepath = path.join(tmp.path, "pretty.json")
326      const data = { key: "value" }
327 
328      await Filesystem.writeJson(filepath, data)
329 
330      const content = await fs.readFile(filepath, "utf-8")
331      expect(content).toContain("\n")
332      expect(content).toContain("  ")
333    })
334 
335    test("writes with permissions", async () => {
336      await using tmp = await tmpdir()
337      const filepath = path.join(tmp.path, "config.json")
338      const data = { secret: "data" }
339 
340      await Filesystem.writeJson(filepath, data, 0o600)
341 
342      const stats = await fs.stat(filepath)
343      if (process.platform !== "win32") {
344        expect(stats.mode & 0o777).toBe(0o600)
345      }
346    })
347  })
348 
349  describe("mimeType()", () => {
350    test("returns correct MIME type for JSON", async () => {
351      expect(await Filesystem.mimeType("test.json")).toContain("application/json")
352    })
353 
354    test("returns correct MIME type for JavaScript", async () => {
355      expect(await Filesystem.mimeType("test.js")).toContain("javascript")
356    })
357 
358    test("returns MIME type for TypeScript (or video/mp2t due to extension conflict)", async () => {
359      const mime = await Filesystem.mimeType("test.ts")
360      // .ts is ambiguous: TypeScript vs MPEG-2 TS video
361      expect(mime === "video/mp2t" || mime === "application/typescript" || mime === "text/typescript").toBe(true)
362    })
363 
364    test("returns correct MIME type for images", async () => {
365      expect(await Filesystem.mimeType("test.png")).toContain("image/png")
366      expect(await Filesystem.mimeType("test.jpg")).toContain("image/jpeg")
367    })
368 
369    test("returns default for unknown extension", async () => {
370      expect(await Filesystem.mimeType("test.unknown")).toBe("application/octet-stream")
371    })
372 
373    test("handles files without extension", async () => {
374      expect(await Filesystem.mimeType("Makefile")).toBe("application/octet-stream")
375    })
376  })
377 
378  describe("windowsPath()", () => {
379    test("converts Git Bash paths", () => {
380      if (process.platform === "win32") {
381        expect(Filesystem.windowsPath("/c/Users/test")).toBe("C:/Users/test")
382        expect(Filesystem.windowsPath("/d/dev/project")).toBe("D:/dev/project")
383      } else {
384        expect(Filesystem.windowsPath("/c/Users/test")).toBe("/c/Users/test")
385      }
386    })
387 
388    test("converts Cygwin paths", () => {
389      if (process.platform === "win32") {
390        expect(Filesystem.windowsPath("/cygdrive/c/Users/test")).toBe("C:/Users/test")
391        expect(Filesystem.windowsPath("/cygdrive/x/dev/project")).toBe("X:/dev/project")
392      } else {
393        expect(Filesystem.windowsPath("/cygdrive/c/Users/test")).toBe("/cygdrive/c/Users/test")
394      }
395    })
396 
397    test("converts WSL paths", () => {
398      if (process.platform === "win32") {
399        expect(Filesystem.windowsPath("/mnt/c/Users/test")).toBe("C:/Users/test")
400        expect(Filesystem.windowsPath("/mnt/z/dev/project")).toBe("Z:/dev/project")
401      } else {
402        expect(Filesystem.windowsPath("/mnt/c/Users/test")).toBe("/mnt/c/Users/test")
403      }
404    })
405 
406    test("ignores normal Windows paths", () => {
407      expect(Filesystem.windowsPath("C:/Users/test")).toBe("C:/Users/test")
408      expect(Filesystem.windowsPath("D:\\dev\\project")).toBe("D:\\dev\\project")
409    })
410  })
411 
412  describe("writeStream()", () => {
413    test("writes from Web ReadableStream", async () => {
414      await using tmp = await tmpdir()
415      const filepath = path.join(tmp.path, "streamed.txt")
416      const content = "Hello from stream!"
417      const encoder = new TextEncoder()
418      const stream = new ReadableStream({
419        start(controller) {
420          controller.enqueue(encoder.encode(content))
421          controller.close()
422        },
423      })
424 
425      await Filesystem.writeStream(filepath, stream)
426 
427      expect(await fs.readFile(filepath, "utf-8")).toBe(content)
428    })
429 
430    test("writes from Node.js Readable stream", async () => {
431      await using tmp = await tmpdir()
432      const filepath = path.join(tmp.path, "node-streamed.txt")
433      const content = "Hello from Node stream!"
434      const { Readable } = await import("stream")
435      const stream = Readable.from([content])
436 
437      await Filesystem.writeStream(filepath, stream)
438 
439      expect(await fs.readFile(filepath, "utf-8")).toBe(content)
440    })
441 
442    test("writes binary data from Web ReadableStream", async () => {
443      await using tmp = await tmpdir()
444      const filepath = path.join(tmp.path, "binary.dat")
445      const binaryData = new Uint8Array([0x00, 0x01, 0x02, 0x03, 0xff])
446      const stream = new ReadableStream({
447        start(controller) {
448          controller.enqueue(binaryData)
449          controller.close()
450        },
451      })
452 
453      await Filesystem.writeStream(filepath, stream)
454 
455      const read = await fs.readFile(filepath)
456      expect(Buffer.from(read)).toEqual(Buffer.from(binaryData))
457    })
458 
459    test("writes large content in chunks", async () => {
460      await using tmp = await tmpdir()
461      const filepath = path.join(tmp.path, "large.txt")
462      const chunks = ["chunk1", "chunk2", "chunk3", "chunk4", "chunk5"]
463      const stream = new ReadableStream({
464        start(controller) {
465          for (const chunk of chunks) {
466            controller.enqueue(new TextEncoder().encode(chunk))
467          }
468          controller.close()
469        },
470      })
471 
472      await Filesystem.writeStream(filepath, stream)
473 
474      expect(await fs.readFile(filepath, "utf-8")).toBe(chunks.join(""))
475    })
476 
477    test("creates parent directories", async () => {
478      await using tmp = await tmpdir()
479      const filepath = path.join(tmp.path, "nested", "deep", "streamed.txt")
480      const content = "nested stream content"
481      const stream = new ReadableStream({
482        start(controller) {
483          controller.enqueue(new TextEncoder().encode(content))
484          controller.close()
485        },
486      })
487 
488      await Filesystem.writeStream(filepath, stream)
489 
490      expect(await fs.readFile(filepath, "utf-8")).toBe(content)
491    })
492 
493    test("writes with permissions", async () => {
494      await using tmp = await tmpdir()
495      const filepath = path.join(tmp.path, "protected-stream.txt")
496      const content = "secret stream content"
497      const stream = new ReadableStream({
498        start(controller) {
499          controller.enqueue(new TextEncoder().encode(content))
500          controller.close()
501        },
502      })
503 
504      await Filesystem.writeStream(filepath, stream, 0o600)
505 
506      const stats = await fs.stat(filepath)
507      if (process.platform !== "win32") {
508        expect(stats.mode & 0o777).toBe(0o600)
509      }
510    })
511 
512    test("writes executable with permissions", async () => {
513      await using tmp = await tmpdir()
514      const filepath = path.join(tmp.path, "script.sh")
515      const content = "#!/bin/bash\necho hello"
516      const stream = new ReadableStream({
517        start(controller) {
518          controller.enqueue(new TextEncoder().encode(content))
519          controller.close()
520        },
521      })
522 
523      await Filesystem.writeStream(filepath, stream, 0o755)
524 
525      const stats = await fs.stat(filepath)
526      if (process.platform !== "win32") {
527        expect(stats.mode & 0o777).toBe(0o755)
528      }
529      expect(await fs.readFile(filepath, "utf-8")).toBe(content)
530    })
531  })
532 
533  describe("resolve()", () => {
534    test("resolves slash-prefixed drive paths on Windows", async () => {
535      if (process.platform !== "win32") return
536      await using tmp = await tmpdir()
537      const forward = tmp.path.replaceAll("\\", "/")
538      expect(Filesystem.resolve(`/${forward}`)).toBe(Filesystem.normalizePath(tmp.path))
539    })
540 
541    test("resolves slash-prefixed drive roots on Windows", async () => {
542      if (process.platform !== "win32") return
543      await using tmp = await tmpdir()
544      const drive = tmp.path[0].toUpperCase()
545      expect(Filesystem.resolve(`/${drive}:`)).toBe(Filesystem.resolve(`${drive}:/`))
546    })
547 
548    test("resolves Git Bash and MSYS2 paths on Windows", async () => {
549      // Git Bash and MSYS2 both use /<drive>/... paths on Windows.
550      if (process.platform !== "win32") return
551      await using tmp = await tmpdir()
552      const drive = tmp.path[0].toLowerCase()
553      const rest = tmp.path.slice(2).replaceAll("\\", "/")
554      expect(Filesystem.resolve(`/${drive}${rest}`)).toBe(Filesystem.normalizePath(tmp.path))
555    })
556 
557    test("resolves Git Bash and MSYS2 drive roots on Windows", async () => {
558      // Git Bash and MSYS2 both use /<drive> paths on Windows.
559      if (process.platform !== "win32") return
560      await using tmp = await tmpdir()
561      const drive = tmp.path[0].toLowerCase()
562      expect(Filesystem.resolve(`/${drive}`)).toBe(Filesystem.resolve(`${drive.toUpperCase()}:/`))
563    })
564 
565    test("resolves Cygwin paths on Windows", async () => {
566      if (process.platform !== "win32") return
567      await using tmp = await tmpdir()
568      const drive = tmp.path[0].toLowerCase()
569      const rest = tmp.path.slice(2).replaceAll("\\", "/")
570      expect(Filesystem.resolve(`/cygdrive/${drive}${rest}`)).toBe(Filesystem.normalizePath(tmp.path))
571    })
572 
573    test("resolves Cygwin drive roots on Windows", async () => {
574      if (process.platform !== "win32") return
575      await using tmp = await tmpdir()
576      const drive = tmp.path[0].toLowerCase()
577      expect(Filesystem.resolve(`/cygdrive/${drive}`)).toBe(Filesystem.resolve(`${drive.toUpperCase()}:/`))
578    })
579 
580    test("resolves WSL mount paths on Windows", async () => {
581      if (process.platform !== "win32") return
582      await using tmp = await tmpdir()
583      const drive = tmp.path[0].toLowerCase()
584      const rest = tmp.path.slice(2).replaceAll("\\", "/")
585      expect(Filesystem.resolve(`/mnt/${drive}${rest}`)).toBe(Filesystem.normalizePath(tmp.path))
586    })
587 
588    test("resolves WSL mount roots on Windows", async () => {
589      if (process.platform !== "win32") return
590      await using tmp = await tmpdir()
591      const drive = tmp.path[0].toLowerCase()
592      expect(Filesystem.resolve(`/mnt/${drive}`)).toBe(Filesystem.resolve(`${drive.toUpperCase()}:/`))
593    })
594 
595    test("resolves symlinked directory to canonical path", async () => {
596      await using tmp = await tmpdir()
597      const target = path.join(tmp.path, "real")
598      await fs.mkdir(target)
599      const link = path.join(tmp.path, "link")
600      await fs.symlink(target, link)
601      expect(Filesystem.resolve(link)).toBe(Filesystem.resolve(target))
602    })
603 
604    test("returns unresolved path when target does not exist", async () => {
605      await using tmp = await tmpdir()
606      const missing = path.join(tmp.path, "does-not-exist-" + Date.now())
607      const result = Filesystem.resolve(missing)
608      expect(result).toBe(Filesystem.normalizePath(path.resolve(missing)))
609    })
610 
611    test("throws ELOOP on symlink cycle", async () => {
612      await using tmp = await tmpdir()
613      const a = path.join(tmp.path, "a")
614      const b = path.join(tmp.path, "b")
615      await fs.symlink(b, a)
616      await fs.symlink(a, b)
617      expect(() => Filesystem.resolve(a)).toThrow()
618    })
619 
620    // Windows: chmod(0o000) is a no-op, so EACCES cannot be triggered
621    test("throws EACCES on permission-denied symlink target", async () => {
622      if (process.platform === "win32") return
623      if (process.getuid?.() === 0) return // skip when running as root
624      await using tmp = await tmpdir()
625      const dir = path.join(tmp.path, "restricted")
626      await fs.mkdir(dir)
627      const link = path.join(tmp.path, "link")
628      await fs.symlink(dir, link)
629      await fs.chmod(dir, 0o000)
630      try {
631        expect(() => Filesystem.resolve(path.join(link, "child"))).toThrow()
632      } finally {
633        await fs.chmod(dir, 0o755)
634      }
635    })
636 
637    // Windows: traversing through a file throws ENOENT (not ENOTDIR),
638    // which resolve() catches as a fallback instead of rethrowing
639    test("rethrows non-ENOENT errors", async () => {
640      if (process.platform === "win32") return
641      await using tmp = await tmpdir()
642      const file = path.join(tmp.path, "not-a-directory")
643      await fs.writeFile(file, "x")
644      expect(() => Filesystem.resolve(path.join(file, "child"))).toThrow()
645    })
646  })
647 
648  describe("normalizePathPattern()", () => {
649    test("preserves drive root globs on Windows", async () => {
650      if (process.platform !== "win32") return
651      await using tmp = await tmpdir()
652      const root = path.parse(tmp.path).root
653      expect(Filesystem.normalizePathPattern(path.join(root, "*"))).toBe(path.join(root, "*"))
654    })
655  })
656})
657