v4.1.18

changelog.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 2026-03-05 - 4.1.18 - fix(mod_compiler)
+add diagnostic logging of output directory states after compilation and after import-path rewriting to aid debugging
+
+- Imported fs to allow reading output directories for diagnostics
+- Logs entries and directory counts for each successful output directory both pre- and post-import-path-rewrite
+- Diagnostics are gated by !isQuiet && !isJson and are read-only (no behavior change)
+- Tags used: 'diag' (post-compilation) and 'diag-post-rewrite' (after rewriting) to help identify missing or unexpected output folders
+
+## 2026-03-05 - 4.1.17 - fix(tsunpacker)
+use synchronous fs operations in tsunpacker to avoid readdir race conditions
+
+- Replaced async fs.promises.readdir/rename/rm/rmdir loops with fs.readdirSync/renameSync/rmSync/rmdirSync
+- Removed readdir retry loops that attempted to handle partial/stale readdir results
+- Updated comment to document rationale: avoid race conditions under signal pressure and XFS metadata lag
+- Note: function remains async but now performs blocking sync filesystem calls which may block the event loop during unpack
+
+## 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
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsbuild",
-  "version": "4.1.14",
+  "version": "4.1.18",
   "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.14',
+  version: '4.1.18',
   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,5 +1,6 @@
 import type { CompilerOptions, Diagnostic, Program } from 'typescript';
 import typescript from 'typescript';
+import * as fs from 'fs';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartpath from '@push.rocks/smartpath';
@@ -371,6 +372,21 @@ export class TsCompiler {
         successfulOutputDirs.push(destDir);
       }
 
+      // Diagnostic: log all output directory states after each compilation
+      if (!isQuiet && !isJson) {
+        for (const prevDir of successfulOutputDirs) {
+          try {
+            const entries = fs.readdirSync(prevDir);
+            const dirs = entries.filter(e => {
+              try { return fs.statSync(prevDir + '/' + e).isDirectory(); } catch { return false; }
+            });
+            console.log(`   📋 [diag] ${prevDir.replace(this.cwd + '/', '')}: ${entries.length} entries, ${dirs.length} dirs`);
+          } catch {
+            console.log(`   📋 [diag] ${prevDir.replace(this.cwd + '/', '')}: MISSING!`);
+          }
+        }
+      }
+
     }
 
     // Rewrite import paths in all output directories to handle cross-module references
@@ -385,6 +401,21 @@ export class TsCompiler {
       if (totalRewritten > 0 && !isQuiet && !isJson) {
         console.log(`   🔄 Rewrote import paths in ${totalRewritten} file${totalRewritten !== 1 ? 's' : ''}`);
       }
+
+      // Diagnostic: log output directory states after path rewriting
+      if (!isQuiet && !isJson) {
+        for (const dir of successfulOutputDirs) {
+          try {
+            const entries = fs.readdirSync(dir);
+            const dirs = entries.filter(e => {
+              try { return fs.statSync(dir + '/' + e).isDirectory(); } catch { return false; }
+            });
+            console.log(`   📋 [diag-post-rewrite] ${dir.replace(this.cwd + '/', '')}: ${entries.length} entries, ${dirs.length} dirs`);
+          } catch {
+            console.log(`   📋 [diag-post-rewrite] ${dir.replace(this.cwd + '/', '')}: MISSING!`);
+          }
+        }
+      }
     }
 
     // Merge all error summaries

ts/mod_fs/classes.fshelpers.ts

@@ -134,34 +134,4 @@ export class FsHelpers {
   public static async move(src: string, dest: string): Promise<void> {
     await fs.promises.rename(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;
-      }
-    }
-  }
 }

ts/mod_unpack/classes.tsunpacker.ts

@@ -1,3 +1,4 @@
+import * as fs from 'fs';
 import * as path from 'path';
 import { TsPublishConfig } from '../mod_config/index.js';
 import { FsHelpers } from '../mod_fs/index.js';
@@ -82,9 +83,16 @@ export class TsUnpacker {
   /**
    * Perform the unpack operation - flatten nested output directories.
    *
-   * Renames the nested directory to a temp location, removes the dest dir,
+   * When TypeScript compiles files that import from sibling directories,
-   * then renames the temp dir back as dest. Uses only rename operations
+   * it creates a nested structure like dist_ts/ts/ with siblings like
-   * which are atomic at the kernel level.
+   * 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
+   *
+   * Uses synchronous fs operations to avoid race conditions with
+   * async readdir returning partial/stale results under signal pressure
+   * or XFS metadata lag (observed in process-group environments like gitzone).
    *
    * Returns true if unpacking was performed, false if skipped.
    */
@@ -98,19 +106,26 @@ export class TsUnpacker {
     }
 
     const nestedPath = this.getNestedPath();
-    const tempPath = this.destDir + '.__unpack_temp__';
 
-    // Step 1: Clean up any leftover temp dir from a previous failed run
+    // Step 1: Remove sibling entries (everything in dest except the source folder)
-    await FsHelpers.removeDirectory(tempPath);
+    const destEntries = fs.readdirSync(this.destDir);
+    for (const entry of destEntries) {
+      if (entry !== this.sourceFolderName) {
+        fs.rmSync(path.join(this.destDir, entry), { recursive: true, force: true });
+      }
+    }
 
-    // Step 2: Rename nested → temp
+    // Step 2: Move all contents from nested dir up to dest dir
-    await FsHelpers.move(nestedPath, tempPath);
+    const nestedEntries = fs.readdirSync(nestedPath);
+    for (const entry of nestedEntries) {
+      fs.renameSync(
+        path.join(nestedPath, entry),
+        path.join(this.destDir, entry),
+      );
+    }
 
-    // Step 3: Remove dest dir (now contains only sibling folders)
+    // Step 3: Remove the now-empty nested directory
-    await FsHelpers.removeDirectory(this.destDir);
+    fs.rmdirSync(nestedPath);
-
-    // Step 4: Rename temp → dest
-    await FsHelpers.move(tempPath, this.destDir);
 
     return true;
   }