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 10ms initial delay after write on Windows
3. Verify file accessibility with up to 3 retries (10ms each)
4. Total potential wait time: 10ms + (3 × 10ms) = 40ms 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 kept minimal since the retry logic handles failures.

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"

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,45 @@ async function retryWrite(
     try {
       // eslint-disable-next-line no-await-in-loop
       await fsPromises.writeFile(filepath, content)
+      // On Windows, add a small delay and verify file exists to ensure it's fully flushed
+      // This prevents ENOENT errors when immediately reading after write
+      if (process.platform === 'win32') {
+        // Small initial delay to allow OS to flush the write
+        // eslint-disable-next-line no-await-in-loop
+        await sleep(10)
+        // Verify the file is actually readable with retries
+        let accessRetries = 0
+        const maxAccessRetries = 3
+        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 a bit more
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(10)
+            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)
     }
   }
 }