v4.1.16

changelog.md

@@ -1,5 +1,59 @@
 # Changelog
 
+## 2026-03-05 - 4.1.16 - fix(mod_unpack)
+handle partial readdir results from signal-interrupted getdents64 when unpacking to ensure sibling removal and nested moves complete
+
+- Loop readdir calls for destination directory until only the source folder remains to avoid partial-listing leftovers
+- Loop readdir calls for nested directory and repeatedly rename entries until the nested directory is empty
+- Prevents leftover files and incomplete moves when readdir returns partial results under signals
+
+## 2026-03-05 - 4.1.15 - fix(mod_unpack)
+flatten nested output directory without temporary rename steps to avoid race conditions
+
+- Replace rename-rm-rename strategy with: remove sibling entries in destination, move nested source entries up into the destination, then remove the now-empty nested folder.
+- Avoid creating temporary sibling directories and avoid removing the destination directory to reduce filesystem race conditions and metadata lag issues (XFS/NFS/etc.).
+- Remove removed removeEmptyDirectory helper and stop using FsHelpers.move/removeDirectory in unpack; import and use fs.promises methods (readdir, rm, rename, rmdir) directly.
+
+## 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
+
+- Replaced async fs.promises.rename/rm and readdir/stat debugging with execSync rm -rf and mv operations for sequential, atomic moves
+- Imported execSync from child_process and removed verbose console logging and extra fs checks
+- Addresses race conditions observed on filesystems like XFS where libuv async operations can return partial results or ENOENT errors
+
+## 2026-03-05 - 4.1.12 - fix(mod_compiler)
+replace runtime require calls with top-level imports and use execSync/path.join for filesystem sync and traversal
+
+- Added top-level imports: path and execSync from child_process
+- Replaced require('child_process').execSync('sync') with execSync('sync') to force fs sync
+- Replaced require('path').join(...) with path.join(...) when recursing directories
+- Refactor is purely local/maintenance-focused (consistency and slight performance/readability improvement); no functional change expected
+
+## 2026-03-05 - 4.1.11 - fix(mod_compiler)
+flush directory entries before unpack to avoid XFS delayed-log causing partial readdir results
+
+- Add fs import and call child_process.execSync('sync') before unpacking compiled output to force kernel-level sync
+- Add syncDirectoryTree(dir) to recursively open and fsync directory file descriptors and traverse subdirectories
+- Call syncDirectoryTree on the destination directory before performing unpack to ensure TypeScript writeFileSync entries are committed (prevents partial readdir results on XFS)
+- Errors during directory sync are ignored to avoid breaking normal flow
+
+## 2026-03-05 - 4.1.10 - fix(unpack)
+use atomic renames to flatten nested output and make unpacking more reliable
+
+- Replace per-entry moves with an atomic 3-step strategy: rename nested dir to a temp location, remove the destination dir, then rename temp back to the destination to avoid partial readdir/move under signal pressure.
+- FsHelpers.move switched from sync rename to fs.promises.rename to work with async flows.
+- Use fs.promises.rm with retries and explicit temp-dir cleanup to handle previous failed runs.
+- Add diagnostic logging and verification of intermediate states.
+- Removed the older removeSiblingDirectories and moveNestedContentsUp methods in favor of the new rename-based approach.
+
 ## 2026-03-05 - 4.1.9 - fix(fs)
 improve filesystem helpers: use sync rename for reliability on certain filesystems; retry rmdir with delays and avoid recursive rm; bump @push.rocks/smartfs to ^1.3.2
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsbuild",
-  "version": "4.1.9",
+  "version": "4.1.16",
   "private": false,
   "description": "A tool for compiling TypeScript files using the latest nightly features, offering flexible APIs and a CLI for streamlined development.",
   "main": "dist_ts/index.js",

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tsbuild',
-  version: '4.1.9',
+  version: '4.1.16',
   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

@@ -367,12 +367,7 @@ export class TsCompiler {
 
       // Perform unpack if compilation succeeded
       if (result.errorSummary.totalErrors === 0) {
-        try {
-          await performUnpack(pattern, destDir, this.cwd);
-        } catch (unpackErr: any) {
-          console.error(`   ⚠️ Unpack error for ${destPath}: ${unpackErr.message}`);
-        }
-
+        await performUnpack(pattern, destDir, this.cwd);
         successfulOutputDirs.push(destDir);
       }
 

ts/mod_fs/classes.fshelpers.ts

@@ -130,40 +130,8 @@ export class FsHelpers {
 
   /**
    * Move/rename a file or directory
-   * Uses renameSync for reliability on XFS/mounted filesystems where async
-   * rename can be interrupted by signals from process managers
    */
   public static async move(src: string, dest: string): Promise<void> {
-    fs.renameSync(src, dest);
-  }
-
-  /**
-   * Remove an empty directory
-   */
-  public static async removeEmptyDirectory(dirPath: string): Promise<void> {
-    // Retry rmdir with delays to handle filesystem metadata lag (XFS, NFS, etc.)
-    // NEVER use recursive rm here — if rmdir fails with ENOTEMPTY, entries may
-    // still be valid references to renamed files/dirs that haven't fully detached
-    for (let attempt = 0; attempt < 5; attempt++) {
-      try {
-        await fs.promises.rmdir(dirPath);
-        return;
-      } catch (err: any) {
-        if (err.code === 'ENOENT') {
-          return; // Already gone
-        }
-        if (err.code === 'ENOTEMPTY' && attempt < 4) {
-          // Wait for filesystem metadata to catch up
-          await new Promise(resolve => setTimeout(resolve, 100 * (attempt + 1)));
-          continue;
-        }
-        // Final attempt failed or non-retryable error — leave directory in place
-        // It will be cleaned up by the next build's "clear output directory" step
-        if (err.code === 'ENOTEMPTY') {
-          return;
-        }
-        throw err;
-      }
-    }
+    await fs.promises.rename(src, dest);
   }
 }

ts/mod_unpack/classes.tsunpacker.ts

@@ -81,62 +81,62 @@ export class TsUnpacker {
   }
 
   /**
-   * Perform the unpack operation - flatten nested output directories
-   * Returns true if unpacking was performed, false if skipped
+   * Perform the unpack operation - flatten nested output directories.
+   *
+   * When TypeScript compiles files that import from sibling directories,
+   * it creates a nested structure like dist_ts/ts/ with siblings like
+   * dist_ts/ts_interfaces/. This method flattens by:
+   * 1. Removing sibling directories (non-source folders)
+   * 2. Moving contents of the nested source folder up to the dest dir
+   * 3. Removing the now-empty nested source folder
+   *
+   * This approach never creates temporary sibling directories and never
+   * removes the destination directory itself, avoiding filesystem race
+   * conditions observed with the previous rename-rm-rename pattern.
+   *
+   * Returns true if unpacking was performed, false if skipped.
    */
   public async unpack(): Promise<boolean> {
-    // Check if we should unpack based on config
     if (!(await this.shouldUnpack())) {
       return false;
     }
 
-    // Check if nested structure exists
     if (!(await this.detectNesting())) {
       return false;
     }
 
     const nestedPath = this.getNestedPath();
 
-    // Delete sibling folders (not the source folder)
-    await this.removeSiblingDirectories();
+    // Step 1: Remove sibling entries (everything in dest except the source folder)
+    // Loop handles partial readdir results from signal-interrupted getdents64
+    let destEntries = await fs.promises.readdir(this.destDir);
+    while (destEntries.some(e => e !== this.sourceFolderName)) {
+      for (const entry of destEntries) {
+        if (entry !== this.sourceFolderName) {
+          await fs.promises.rm(path.join(this.destDir, entry), { recursive: true, force: true });
+        }
+      }
+      destEntries = await fs.promises.readdir(this.destDir);
+    }
 
-    // Move contents from nested folder up
-    await this.moveNestedContentsUp();
+    // Step 2: Move all contents from nested dir up to dest dir
+    // Loop handles partial readdir results from signal-interrupted getdents64
+    let nestedEntries = await fs.promises.readdir(nestedPath);
+    while (nestedEntries.length > 0) {
+      for (const entry of nestedEntries) {
+        await fs.promises.rename(
+          path.join(nestedPath, entry),
+          path.join(this.destDir, entry),
+        );
+      }
+      nestedEntries = await fs.promises.readdir(nestedPath);
+    }
 
-    // Remove empty nested folder
-    await FsHelpers.removeEmptyDirectory(nestedPath);
+    // Step 3: Remove the now-empty nested directory
+    await fs.promises.rmdir(nestedPath);
 
     return true;
   }
-
-  /**
-   * Remove sibling directories in the destination folder
-   * (directories other than the source folder being unpacked)
-   */
-  private async removeSiblingDirectories(): Promise<void> {
-    const entries = await FsHelpers.listDirectory(this.destDir);
-    for (const entry of entries) {
-      if (entry.isDirectory && entry.name !== this.sourceFolderName) {
-        await FsHelpers.removeDirectory(path.join(this.destDir, entry.name));
-      }
-    }
-  }
-
-  /**
-   * Move contents from the nested folder up to the destination directory
-   */
-  private async moveNestedContentsUp(): Promise<void> {
-    const nestedPath = this.getNestedPath();
-    const entries = await FsHelpers.listDirectory(nestedPath);
-    const dirCount = entries.filter(e => e.isDirectory).length;
-    const fileCount = entries.filter(e => e.isFile).length;
-    console.log(`   📦 Unpacking ${this.sourceFolderName}/: ${dirCount} directories, ${fileCount} files`);
-    for (const entry of entries) {
-      const src = path.join(nestedPath, entry.name);
-      const dest = path.join(this.destDir, entry.name);
-      await FsHelpers.move(src, dest);
-    }
-  }
 }
 
 /**