fix(windows): add file flush delay to prevent ENOENT errors in tests

On Windows, file operations can be asynchronous at the OS level. After writeFile() completes, the file handle may not be fully released immediately, causing ENOENT errors when code tries to read the file right after writing.

Enhanced retryWrite() with ENOENT retry support:
1. **Retry on ENOENT errors** (not just EPERM/EBUSY) - this is the key fix
2. Add 25ms initial delay after write on Windows
3. Verify file accessibility with up to 4 retries with increasing delays (15ms, 30ms, 45ms, 60ms)
4. Total potential wait time: 25ms + (15+30+45+60)ms = 175ms max

Root cause: The previous code only retried EPERM/EBUSY errors. The write
itself can fail with ENOENT on Windows if the filesystem is slow to make
the file available. Adding ENOENT to the retry conditions is the critical
fix. The delays are tuned for Windows CI runners which are slower than
local development environments.

This fixes intermittent test failures in Windows CI runners, including:
- "should handle load -> update -> save workflow"
- "should use default 2-space indent for new files"
- "should preserve line endings"
- "should support sort option"
- "should use LF line endings by default"
- "should handle save -> update -> save again"

Author: jdalton

src/json/edit.ts

@@ -2,6 +2,8 @@
  * @fileoverview Editable JSON file manipulation with formatting preservation.
  */
 
+import { setTimeout as sleep } from 'node:timers/promises'
+
 import {
   INDENT_SYMBOL,
   NEWLINE_SYMBOL,
@@ -58,23 +60,47 @@ async function retryWrite(
     try {
       // eslint-disable-next-line no-await-in-loop
       await fsPromises.writeFile(filepath, content)
+      // On Windows, add a delay and verify file exists to ensure it's fully flushed
+      // This prevents ENOENT errors when immediately reading after write
+      // Windows CI runners need longer delays than local development
+      if (process.platform === 'win32') {
+        // Initial delay to allow OS to flush the write
+        // eslint-disable-next-line no-await-in-loop
+        await sleep(25)
+        // Verify the file is actually readable with retries
+        let accessRetries = 0
+        const maxAccessRetries = 4
+        while (accessRetries < maxAccessRetries) {
+          try {
+            // eslint-disable-next-line no-await-in-loop
+            await fsPromises.access(filepath)
+            break
+          } catch {
+            // If file isn't accessible yet, wait with increasing delays
+            const delay = 15 * (accessRetries + 1)
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(delay)
+            accessRetries++
+          }
+        }
+      }
       return
     } catch (err) {
       const isLastAttempt = attempt === retries
-      const isEperm =
+      const isRetriableError =
         err instanceof Error &&
         'code' in err &&
-        (err.code === 'EPERM' || err.code === 'EBUSY')
+        (err.code === 'EPERM' || err.code === 'EBUSY' || err.code === 'ENOENT')
 
-      // Only retry on Windows EPERM/EBUSY errors, and not on the last attempt
-      if (!isEperm || isLastAttempt) {
+      // Only retry on Windows file system errors (EPERM/EBUSY/ENOENT), and not on the last attempt
+      if (!isRetriableError || isLastAttempt) {
         throw err
       }
 
       // Exponential backoff: 10ms, 20ms, 40ms
       const delay = baseDelay * 2 ** attempt
       // eslint-disable-next-line no-await-in-loop
-      await new Promise(resolve => setTimeout(resolve, delay))
+      await sleep(delay)
     }
   }
 }