Merge remote-tracking branch 'origin/main' into chenjiahan/perf-fmt-parser-worker

# Conflicts:
#	packages/rstack/src/fmt/worker.ts
#	packages/rstack/tests/fmt/worker.test.ts

Author: chenjiahan

packages/rstack/THIRD_PARTY_NOTICES.md

@@ -88,35 +88,6 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
-## atomically
-
-This package includes bundled code from
-[atomically](https://github.com/fabiospampinato/atomically).
-
-License: MIT
-
-The MIT License (MIT)
-
-Copyright (c) 2020-present Fabio Spampinato
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the "Software"),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
 ## fast-ignore
 
 This package includes bundled code from [fast-ignore](https://github.com/fabiospampinato/fast-ignore).

packages/rstack/package.json

@@ -69,7 +69,6 @@
     "@rstest/adapter-rslib": "catalog:",
     "@types/micromatch": "catalog:",
     "@types/node": "catalog:",
-    "atomically": "catalog:",
     "fast-ignore": "catalog:",
     "ignore": "catalog:",
     "import-meta-resolve": "catalog:",

packages/rstack/src/fmt/worker.ts

@@ -1,21 +1,15 @@
 // Derived from @prettier/cli, see THIRD_PARTY_NOTICES.md
 
-import { readFile, writeFile } from 'atomically';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { format } from 'prettier';
 import { resolveFmtParser } from './parser.ts';
 import { getPrettierPlugins } from './prettierPlugins.ts';
 import type { FmtFileRequest, FmtWorkerFileResult } from './types.ts';
 
 /**
- * Formatting output can be regenerated, so avoid waiting for a durability sync
- * after every file, which is especially expensive during parallel formatting.
- * `atomically` still uses a temporary file and rename for atomic replacement.
+ * Use synchronous direct I/O inside the dedicated worker to avoid libuv
+ * scheduling overhead. This prioritizes throughput over crash-safe replacement.
  */
-const atomicWriteOptions = {
-  encoding: 'utf8',
-  fsync: false,
-} as const;
-
 const formatFile = async (
   { path, options }: FmtFileRequest,
   shouldWrite: boolean,
@@ -26,7 +20,7 @@ const formatFile = async (
     return 'unsupported';
   }
 
-  const source = await readFile(path, 'utf8');
+  const source = readFileSync(path, 'utf8');
   const formatted = await format(source, {
     ...options,
     parser,
@@ -38,7 +32,7 @@ const formatFile = async (
   }
 
   if (shouldWrite) {
-    await writeFile(path, formatted, atomicWriteOptions);
+    writeFileSync(path, formatted, 'utf8');
   }
 
   return 'changed';

packages/rstack/tests/fmt/runnerWriteFailure.test.ts

@@ -8,14 +8,14 @@ const mocks = rs.hoisted(() => ({
 rs.mock('../../src/fmt/parallel.ts', () => ({
   createFmtWorker: () =>
     Promise.resolve({
-      formatFile: () => Promise.reject(new Error('atomic write failed')),
+      formatFile: () => Promise.reject(new Error('file write failed')),
       terminate: () => {
         mocks.terminateCalls++;
       },
     }),
 }));
 
-test('returns an error when the atomic write fails', async () => {
+test('returns an error when a file write fails', async () => {
   const filePath = '/virtual/example.ts';
 
   const result = await runFmtFiles({
@@ -38,7 +38,7 @@ test('returns an error when the atomic write fails', async () => {
       {
         path: filePath,
         status: 'error',
-        error: { message: 'atomic write failed' },
+        error: { message: 'file write failed' },
       },
     ],
   });

packages/rstack/tests/fmt/worker.test.ts

@@ -1,78 +1,61 @@
-import { beforeEach, expect, rs, test } from 'rstack/test';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { expect, test } from 'rstack/test';
 import { formatFile } from '../../src/fmt/worker.ts';
-
-const mocks = rs.hoisted(() => ({
-  readFileCalls: [] as string[],
-  writeFileCalls: [] as [string, string, unknown][],
-}));
-
-rs.mock('atomically', () => ({
-  readFile: (path: string) => {
-    mocks.readFileCalls.push(path);
-    return Promise.resolve('const value=1');
-  },
-  writeFile: (path: string, data: string, options: unknown) => {
-    mocks.writeFileCalls.push([path, data, options]);
-    return Promise.resolve();
-  },
-}));
-
-beforeEach(() => {
-  mocks.readFileCalls.length = 0;
-  mocks.writeFileCalls.length = 0;
-});
-
-test('disables fsync for atomic writes', async () => {
-  const filePath = '/virtual/example.ts';
-
-  await expect(
-    formatFile(
-      {
-        path: filePath,
-        options: {
-          filepath: filePath,
-          parser: 'typescript',
+import { withTempProject, writeProjectFile } from './helpers.ts';
+
+test('writes formatted files', async () => {
+  await withTempProject(async (rootPath) => {
+    const filePath = writeProjectFile(rootPath, 'example.ts', 'const value=1');
+
+    await expect(
+      formatFile(
+        {
+          path: filePath,
+          options: {
+            filepath: filePath,
+            parser: 'typescript',
+          },
         },
-      },
-      true,
-    ),
-  ).resolves.toBe('changed');
+        true,
+      ),
+    ).resolves.toBe('changed');
 
-  expect(mocks.writeFileCalls).toEqual([
-    [filePath, 'const value = 1;\n', { encoding: 'utf8', fsync: false }],
-  ]);
+    expect(readFileSync(filePath, 'utf8')).toBe('const value = 1;\n');
+  });
 });
 
 test('infers the parser before formatting', async () => {
-  const filePath = '/virtual/example.ts';
-
-  await expect(
-    formatFile(
-      {
-        path: filePath,
-        options: { filepath: filePath },
-      },
-      false,
-    ),
-  ).resolves.toBe('changed');
+  await withTempProject(async (rootPath) => {
+    const source = 'const value=1';
+    const filePath = writeProjectFile(rootPath, 'example.ts', source);
+
+    await expect(
+      formatFile(
+        {
+          path: filePath,
+          options: { filepath: filePath },
+        },
+        false,
+      ),
+    ).resolves.toBe('changed');
 
-  expect(mocks.readFileCalls).toEqual([filePath]);
-  expect(mocks.writeFileCalls).toEqual([]);
+    expect(readFileSync(filePath, 'utf8')).toBe(source);
+  });
 });
 
 test('skips unsupported files before reading them', async () => {
-  const filePath = '/virtual/example.unknown';
-
-  await expect(
-    formatFile(
-      {
-        path: filePath,
-        options: { filepath: filePath },
-      },
-      true,
-    ),
-  ).resolves.toBe('unsupported');
-
-  expect(mocks.readFileCalls).toEqual([]);
-  expect(mocks.writeFileCalls).toEqual([]);
+  await withTempProject(async (rootPath) => {
+    const filePath = path.join(rootPath, 'missing.unknown');
+
+    await expect(
+      formatFile(
+        {
+          path: filePath,
+          options: { filepath: filePath },
+        },
+        true,
+      ),
+    ).resolves.toBe('unsupported');
+  });
 });

pnpm-lock.yaml

@@ -35,7 +35,6 @@ catalog:
   '@types/react': '^19.2.18'
   '@types/react-dom': '^19.2.4'
   '@shikijs/transformers': '^4.3.1'
-  atomically: '2.1.1'
   'cspell-ban-words': '^0.0.4'
   'fast-ignore': '2.0.0'
   'happy-dom': '^20.11.1'