fix: atomic-write generated CSS and dts files

Metro spawns multiple worker processes that each transform
`components/web/metro-injected.js` and the CSS entry file. Both
transforms call `buildCSS`, which writes
`node_modules/uniwind/uniwind.css` via `fs.writeFileSync`. That call
truncates the file before writing, so when one worker is mid-write
another worker can observe a partial file as Tailwind compiles
`@import 'uniwind'` from `generateCSSForThemes`/`compileVirtual`.
The partial read fails to parse and surfaces as cryptic errors like:

    SyntaxError: .../metro-injected.js: Missing closing }
    at &:not(:where(.light, .light *, .dark, .dark *, ...))

This is the long-standing flake in #341 and #427: it reproduces on
Linux CI (concurrent workers, low-overhead scheduling) and is
effectively invisible on macOS. Enabling
`EXPO_UNSTABLE_TREE_SHAKING=1` widens the race window by adding
transforms and surfaces it consistently.

Route both `buildCSS` and `buildDtsFile` through a new
`atomicWriteFileSync` helper that stages to a unique temp file in
the same directory and renames onto the target. POSIX `rename` is
atomic and Windows' `MoveFileEx` (used by Node's `fs.renameSync`)
does atomic replace, so concurrent readers always see either the
previous file or the complete new file.

Refs: #341

Author: williamrobertson13

packages/uniwind/src/css/index.ts

@@ -1,5 +1,6 @@
 import fs from 'fs'
 import path from 'path'
+import { atomicWriteFileSync } from '../utils/atomicWriteFileSync'
 import { EXTRA_UTILITIES_CSS } from './extraUtilities'
 import { INSETS_CSS } from './insets'
 import { OVERWRITE_CSS } from './overwrite'
@@ -27,8 +28,5 @@ export const buildCSS = async (themes: Array<string>, input: string) => {
         return
     }
 
-    fs.writeFileSync(
-        cssFilePath,
-        newCssFile,
-    )
+    atomicWriteFileSync(cssFilePath, newCssFile)
 }

packages/uniwind/src/utils/atomicWriteFileSync.ts

@@ -0,0 +1,22 @@
+import crypto from 'crypto'
+import fs from 'fs'
+
+/**
+ * Write a file by staging to a temp path in the same directory and renaming
+ * onto the target. `rename` is atomic on POSIX and Windows, so concurrent
+ * readers always observe either the previous file or the complete new file —
+ * never a partial write. See https://github.com/uni-stack/uniwind/issues/341.
+ */
+export const atomicWriteFileSync = (filePath: string, content: string) => {
+    const tmpPath = `${filePath}.${crypto.randomUUID()}.tmp`
+    fs.writeFileSync(tmpPath, content)
+    try {
+        fs.renameSync(tmpPath, filePath)
+    } catch (err) {
+        // best-effort cleanup
+        try {
+            fs.unlinkSync(tmpPath)
+        } catch {}
+        throw err
+    }
+}

packages/uniwind/src/utils/buildDtsFile.ts

@@ -1,5 +1,6 @@
 import fs from 'fs'
 import { name } from '../../package.json'
+import { atomicWriteFileSync } from './atomicWriteFileSync'
 
 export const buildDtsFile = (dtsPath: string, stringifiedThemes: string) => {
     const oldDtsContent = fs.existsSync(dtsPath)
@@ -23,5 +24,5 @@ export const buildDtsFile = (dtsPath: string, stringifiedThemes: string) => {
         return
     }
 
-    fs.writeFileSync(dtsPath, dtsContent)
+    atomicWriteFileSync(dtsPath, dtsContent)
 }