fix(oxfmt): allow repeated CLI calls in the same process (#27051)

Calling Oxfmt's `runCli()` more than once in the same Node.js process
panics because each call tries to initialize Rayon's global thread pool.

I am working on calling Oxlint and Oxfmt directly within Vite+'s Node.js
process to avoid loading the `vite-plus` package again in each child
process. See the [discussion on
vite-plus#2782](voidzero-dev/vite-plus#2782 (review))
for the profiling context and proposed integration.

This PR initializes the global thread pool once so subsequent CLI calls
reuse it. The first call's thread count remains in effect for the
lifetime of the process.

Related: #21899 addresses the corresponding initialization panics in
Oxlint when calling it repeatedly in the same Node.js process.

🤖 Generated with Codex

---------

Co-authored-by: leaysgur <6259812+leaysgur@users.noreply.github.com>

Author: liangmiQwQ

apps/oxfmt/src/cli/init.rs

@@ -1,40 +1,47 @@
+use std::sync::OnceLock;
+
 /// Initialize Rayon global thread pool with specified number of threads.
 ///
 /// If `--threads` option is not used, or `--threads 0` is given,
 /// default to the number of available CPU cores.
 ///
+/// Repeated calls reuse the pool and thread count from the first call.
+///
 /// # Panics
-/// Panics if the global thread pool has already been initialized.
+/// Panics if another consumer has already initialized the global thread pool.
 #[expect(clippy::print_stderr)]
 pub fn init_rayon(threads: Option<usize>) {
-    // Always initialize thread pool, even if using default thread count,
-    // to ensure thread pool's thread count is locked after this point.
-    // `rayon::current_num_threads()` will always return the same number after this point.
-    //
-    // If you don't initialize the global thread pool explicitly, or don't specify `num_threads`,
-    // Rayon will initialize the thread pool when it's first used, with a thread count of
-    // `std::thread::available_parallelism()`, and that thread count won't change thereafter.
-    // So we don't *need* to initialize the thread pool here if we just want the default thread count.
-    //
-    // However, Rayon's docs state that:
-    // > In the future, the default behavior may change to dynamically add or remove threads as needed.
-    // https://docs.rs/rayon/1.11.0/rayon/struct.ThreadPoolBuilder.html#method.num_threads
-    //
-    // To ensure we continue to have a "locked" thread count, even after future Rayon upgrades,
-    // we always initialize the thread pool and explicitly specify thread count here.
+    static RAYON_INIT: OnceLock<()> = OnceLock::new();
+    RAYON_INIT.get_or_init(|| {
+        // Always initialize thread pool, even if using default thread count,
+        // to ensure thread pool's thread count is locked after this point.
+        // `rayon::current_num_threads()` will always return the same number after this point.
+        //
+        // If you don't initialize the global thread pool explicitly, or don't specify `num_threads`,
+        // Rayon will initialize the thread pool when it's first used, with a thread count of
+        // `std::thread::available_parallelism()`, and that thread count won't change thereafter.
+        // So we don't *need* to initialize the thread pool here if we just want the default thread count.
+        //
+        // However, Rayon's docs state that:
+        // > In the future, the default behavior may change to dynamically add or remove threads as needed.
+        // https://docs.rs/rayon/1.11.0/rayon/struct.ThreadPoolBuilder.html#method.num_threads
+        //
+        // To ensure we continue to have a "locked" thread count, even after future Rayon upgrades,
+        // we always initialize the thread pool and explicitly specify thread count here.
 
-    let thread_count = if let Some(thread_count) = threads
-        && thread_count > 0
-    {
-        thread_count
-    } else if let Ok(thread_count) = std::thread::available_parallelism() {
-        thread_count.get()
-    } else {
-        eprintln!(
-            "Unable to determine available thread count. Defaulting to 1.\nConsider specifying the number of threads explicitly with `--threads` option."
-        );
-        1
-    };
+        let thread_count = if let Some(thread_count) = threads
+            && thread_count > 0
+        {
+            thread_count
+        } else if let Ok(thread_count) = std::thread::available_parallelism() {
+            thread_count.get()
+        } else {
+            eprintln!(
+                "Unable to determine available thread count. Defaulting to 1.\nConsider specifying the number of threads explicitly with `--threads` option."
+            );
+            1
+        };
 
-    rayon::ThreadPoolBuilder::new().num_threads(thread_count).build_global().unwrap();
+        rayon::ThreadPoolBuilder::new().num_threads(thread_count).build_global().unwrap();
+    });
 }