fix(fs): replace execSync and fsync workarounds with atomic async FsHelpers operations to avoid XFS races and shell dependencies

changelog.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 2026-03-05 - 4.1.14 - fix(fs)
+replace execSync and fsync workarounds with atomic async FsHelpers operations to avoid XFS races and shell dependencies
+
+- Removed child_process.execSync usage and shell mv/rm commands in mod_unpack and mod_compiler.
+- Removed syncDirectoryTree and fsync-based workaround from the compiler module.
+- Use FsHelpers.move and FsHelpers.removeDirectory (async rename/remove) for atomic filesystem operations during unpack.
+- Await performUnpack directly and simplify unpack flow to improve portability and reliability on XFS and other filesystems.
+
 ## 2026-03-05 - 4.1.13 - fix(mod_unpack)
 Use child_process.execSync (mv/rm) to perform unpack atomically, replacing async fs operations and logs to avoid ENOENT/partial directory listings on XFS
 

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tsbuild',
-  version: '4.1.13',
+  version: '4.1.14',
   description: 'A tool for compiling TypeScript files using the latest nightly features, offering flexible APIs and a CLI for streamlined development.'
 }

ts/mod_compiler/classes.tscompiler.ts

@@ -1,8 +1,5 @@
 import type { CompilerOptions, Diagnostic, Program } from 'typescript';
 import typescript from 'typescript';
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartpath from '@push.rocks/smartpath';
@@ -370,18 +367,7 @@ export class TsCompiler {
 
       // Perform unpack if compilation succeeded
       if (result.errorSummary.totalErrors === 0) {
-        // Force XFS to commit all pending directory entries before unpacking.
+        await performUnpack(pattern, destDir, this.cwd);
-        // TypeScript's writeFileSync creates entries that may reside in XFS's
-        // delayed log. Without sync, readdir can return partial results.
-        execSync('sync');
-        this.syncDirectoryTree(destDir);
-
-        try {
-          await performUnpack(pattern, destDir, this.cwd);
-        } catch (unpackErr: any) {
-          console.error(`   ⚠️ Unpack error for ${destPath}: ${unpackErr.message}`);
-        }
-
         successfulOutputDirs.push(destDir);
       }
 
@@ -504,27 +490,6 @@ export class TsCompiler {
     return success;
   }
 
-  /**
-   * Recursively fsync all directories in a tree.
-   * Forces XFS to commit pending directory entries from its log.
-   */
-  private syncDirectoryTree(dirPath: string): void {
-    try {
-      const fd = fs.openSync(dirPath, 'r');
-      fs.fsyncSync(fd);
-      fs.closeSync(fd);
-
-      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          this.syncDirectoryTree(path.join(dirPath, entry.name));
-        }
-      }
-    } catch {
-      // Ignore errors (directory may not exist)
-    }
-  }
-
   /**
    * Merge multiple error summaries into one
    */

ts/mod_unpack/classes.tsunpacker.ts

@@ -1,5 +1,4 @@
 import * as path from 'path';
-import { execSync } from 'child_process';
 import { TsPublishConfig } from '../mod_config/index.js';
 import { FsHelpers } from '../mod_fs/index.js';
 
@@ -83,10 +82,9 @@ export class TsUnpacker {
   /**
    * Perform the unpack operation - flatten nested output directories.
    *
-   * Uses shell commands (mv, rm) via execSync for reliability. Node.js async
+   * Renames the nested directory to a temp location, removes the dest dir,
-   * fs operations (rename, rm) can race on XFS filesystems where metadata
+   * then renames the temp dir back as dest. Uses only rename operations
-   * commits are delayed, causing ENOENT or partial directory listings.
+   * which are atomic at the kernel level.
-   * Shell commands execute as direct syscalls without libuv's async layer.
    *
    * Returns true if unpacking was performed, false if skipped.
    */
@@ -102,12 +100,17 @@ export class TsUnpacker {
     const nestedPath = this.getNestedPath();
     const tempPath = this.destDir + '.__unpack_temp__';
 
-    // Use shell commands for atomic, sequential filesystem operations.
+    // Step 1: Clean up any leftover temp dir from a previous failed run
-    // This avoids race conditions between Node.js async fs operations on XFS.
+    await FsHelpers.removeDirectory(tempPath);
-    execSync(`rm -rf "${tempPath}"`, { stdio: 'ignore' });
+
-    execSync(`mv "${nestedPath}" "${tempPath}"`, { stdio: 'ignore' });
+    // Step 2: Rename nested → temp
-    execSync(`rm -rf "${this.destDir}"`, { stdio: 'ignore' });
+    await FsHelpers.move(nestedPath, tempPath);
-    execSync(`mv "${tempPath}" "${this.destDir}"`, { stdio: 'ignore' });
+
+    // Step 3: Remove dest dir (now contains only sibling folders)
+    await FsHelpers.removeDirectory(this.destDir);
+
+    // Step 4: Rename temp → dest
+    await FsHelpers.move(tempPath, this.destDir);
 
     return true;
   }