v4.2.1

changelog.md

@@ -1,5 +1,101 @@
 # Changelog
 
+## 2026-03-05 - 4.2.1 - fix(compiler)
+use TypeScript sys hooks instead of fs monkeypatching to detect writes/deletes in previous output directories
+
+- Replace direct fs.* monkeypatching with interception of typescript.sys.writeFile, typescript.sys.deleteFile and typescript.sys.createDirectory
+- Add guards for optional sys.deleteFile before overriding it and preserve original sys methods to restore after compilation
+- Update diagnostic messages to reference TypeScript sys ops and add an informational message when no ops are observed
+- Reduce surface area of changes by avoiding global fs changes and focusing on TypeScript's sys API for safer interception
+
+## 2026-03-05 - 4.2.0 - feat(mod_compiler)
+add diagnostic interception of fs operations to detect and report unexpected file system changes in previously compiled output directories during compilation
+
+- Wraps fs.unlinkSync, fs.rmSync, fs.rmdirSync, fs.renameSync and fs.writeFileSync to record operations targeting other successful output directories during a compile.
+- Enabled only when there are previously compiled output dirs and when not running in quiet or JSON mode; original fs methods are restored after compilation.
+- Logs up to 30 intercepted operations and prints a summary count if any ops were observed; intercepted calls still perform the original fs action (diagnostic-only).
+- No functional change to compilation behavior beyond additional diagnostic reporting.
+
+## 2026-03-05 - 4.1.26 - fix(compiler)
+fsync output directories after unpack to avoid XFS delayed logging causing corrupt or invisible directory entries during subsequent TypeScript emits
+
+- Force fsync on each successful output directory (open, fsync, close) before the next compilation step.
+- Prevents XFS delayed logging from making directory entries invisible or corrupted during TypeScript emit operations.
+- Operation swallows errors if a directory doesn't exist yet; non-breaking fix with small additional IO.
+
+## 2026-03-05 - 4.1.25 - fix(mod_unpack)
+flush directory metadata on XFS before reading and use readdirSync-based iteration to avoid missing entries when unpacking
+
+- Call fs.fsyncSync on destination and nested directory file descriptors to force XFS to commit delayed directory metadata (addresses XFS CIL delayed logging causing incomplete readdir/opendir results).
+- Replace opendirSync/readSync loops with readdirSync-based iteration for simpler, deterministic directory listing.
+- Remove unused moved counter and update diagnostic log to report nestedEntries.length for moved entry count.
+
+## 2026-03-05 - 4.1.24 - fix(mod_unpack)
+iterate directories with opendirSync/readSync to avoid missing entries on XFS and ensure directory handles are closed
+
+- Replaced readdirSync loops with opendirSync + readSync for destination and nested directories to provide a single stable directory handle during iteration
+- Added explicit closeSync() calls to close directory handles and avoid resource leaks
+- Avoids partial results/missed entries that can occur when repeatedly calling readdirSync (observed on XFS with delayed metadata)
+- Preserves existing renameSync move logic and increments moved counter while cleaning up the now-empty nested directory
+
+## 2026-03-05 - 4.1.23 - fix(mod_unpack)
+handle partial readdirSync results when moving nested directory entries and add diagnostic log
+
+- Loop over readdirSync results until the nested directory is empty to avoid missing entries from partial reads
+- Count moved entries and print a diagnostic message with the final destination entry count
+- Keep removal of the now-empty nested directory (fs.rmdirSync) after moving contents
+
+## 2026-03-05 - 4.1.22 - fix(mod_compiler)
+improve logging of successful output directories to include a sorted list of entries and use a shortened relative path
+
+- Adds shortDir variable to display relative path instead of repeating inline replace(this.cwd + '/')
+- Appends a sorted, comma-separated list of directory entries to the log output for easier inspection
+- Change located in ts/mod_compiler/classes.tscompiler.ts
+
+## 2026-03-05 - 4.1.21 - fix(compiler)
+log emitted files written outside expected destination directory for diagnostics
+
+- Adds diagnostic logging for emitted files that are not under the configured destDir, listing up to 20 example paths and reporting the remaining count.
+- Logging is conditional: only when not in quiet mode and not emitting JSON.
+- Diagnostic runs after compilation (post-compile) and before unpacking of outputs; paths are trimmed using the process cwd for readability.
+
+## 2026-03-05 - 4.1.20 - fix(mod_compiler)
+add diagnostic snapshots for output directories around clear and compile steps
+
+- Introduce diagSnap helper to log entry and directory counts for successful output directories when not in quiet or JSON mode
+- Call diagSnap before clearing the destination directory, after clearing, and after compilation to aid debugging of missing or unexpected outputs
+- Behavior for emitted files and unpacking is unchanged; this is observational/logging-only instrumentation
+
+## 2026-03-05 - 4.1.19 - fix(mod_fs)
+use synchronous rm to avoid XFS metadata corruption when removing directories
+
+- Replaced async fs.promises.rm with synchronous fs.rmSync in removeDirectory to avoid observed XFS metadata corruption affecting sibling entries under libuv thread-pool and signal pressure
+- Retains previous options: recursive, force, maxRetries, retryDelay
+- Adds inline comment documenting the rationale for using a synchronous removal
+
+## 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
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsbuild",
-  "version": "4.1.15",
+  "version": "4.2.1",
   "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.15',
+  version: '4.2.1',
   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';
@@ -337,13 +338,31 @@ export class TsCompiler {
       // Get destination directory as absolute path
       const destDir = smartpath.transform.toAbsolute(destPath, this.cwd) as string;
 
+      // Diagnostic helper
+      const diagSnap = (label: string) => {
+        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; } });
+              const shortDir = prevDir.replace(this.cwd + '/', '');
+              console.log(`   📋 [${label}] ${shortDir}: ${entries.length} entries, ${dirs.length} dirs [${entries.sort().join(', ')}]`);
+            } catch {
+              console.log(`   📋 [${label}] ${prevDir.replace(this.cwd + '/', '')}: MISSING!`);
+            }
+          }
+        }
+      };
+
       // Clear the destination directory before compilation if it exists
+      diagSnap('pre-clear');
       if (await FsHelpers.directoryExists(destDir)) {
         if (!isQuiet && !isJson) {
           console.log(`🧹 Clearing output directory: ${destPath}`);
         }
         await FsHelpers.removeDirectory(destDir);
       }
+      diagSnap('post-clear');
 
       // Update compiler options with the output directory
       const options: CompilerOptions = {
@@ -361,16 +380,108 @@ export class TsCompiler {
         fileCount: absoluteFiles.length,
       };
 
+      // Diagnostic: intercept TypeScript sys operations during compilation to detect
+      // any unexpected writes/deletes in previously compiled output directories
+      const watchedDirs = successfulOutputDirs.filter(d => d !== destDir);
+      let interceptedOps: string[] = [];
+      const origSysWriteFile = typescript.sys.writeFile;
+      const origSysDeleteFile = typescript.sys.deleteFile;
+      const origSysCreateDir = typescript.sys.createDirectory;
+      if (watchedDirs.length > 0 && !isQuiet && !isJson) {
+        typescript.sys.writeFile = (p: string, data: string, writeBom?: boolean) => {
+          if (watchedDirs.some(d => p.startsWith(d + '/'))) {
+            interceptedOps.push(`sys.writeFile: ${p}`);
+          }
+          return origSysWriteFile.call(typescript.sys, p, data, writeBom);
+        };
+        if (origSysDeleteFile) {
+          typescript.sys.deleteFile = (p: string) => {
+            if (watchedDirs.some(d => p.startsWith(d + '/'))) {
+              interceptedOps.push(`sys.deleteFile: ${p}`);
+            }
+            return origSysDeleteFile!.call(typescript.sys, p);
+          };
+        }
+        typescript.sys.createDirectory = (p: string) => {
+          if (watchedDirs.some(d => p.startsWith(d + '/'))) {
+            interceptedOps.push(`sys.createDirectory: ${p}`);
+          }
+          return origSysCreateDir.call(typescript.sys, p);
+        };
+      }
+
       const result = await this.compileFiles(absoluteFiles, options, taskInfo);
       emittedFiles.push(...result.emittedFiles);
       errorSummaries.push(result.errorSummary);
 
+      // Restore original sys methods and report any intercepted operations
+      if (watchedDirs.length > 0 && !isQuiet && !isJson) {
+        typescript.sys.writeFile = origSysWriteFile;
+        typescript.sys.deleteFile = origSysDeleteFile;
+        typescript.sys.createDirectory = origSysCreateDir;
+        if (interceptedOps.length > 0) {
+          console.log(`   ⚠️ [diag] ${interceptedOps.length} TypeScript sys ops on previous output dirs:`);
+          for (const op of interceptedOps.slice(0, 30)) {
+            console.log(`      ${op.replace(this.cwd + '/', '')}`);
+          }
+          if (interceptedOps.length > 30) {
+            console.log(`      ... and ${interceptedOps.length - 30} more`);
+          }
+        } else {
+          console.log(`   ℹ️ [diag] No TypeScript sys ops on previous output dirs during this compilation`);
+        }
+      }
+      diagSnap('post-compile');
+
+      // Diagnostic: log emitted files that went to unexpected directories
+      if (!isQuiet && !isJson && result.emittedFiles.length > 0) {
+        const unexpectedFiles = result.emittedFiles.filter(f => !f.startsWith(destDir + '/') && !f.startsWith(destDir + '\\'));
+        if (unexpectedFiles.length > 0) {
+          console.log(`   ⚠️ [diag] ${unexpectedFiles.length} files emitted OUTSIDE ${destPath}:`);
+          for (const f of unexpectedFiles.slice(0, 20)) {
+            console.log(`      ${f.replace(this.cwd + '/', '')}`);
+          }
+          if (unexpectedFiles.length > 20) {
+            console.log(`      ... and ${unexpectedFiles.length - 20} more`);
+          }
+        }
+      }
+
       // Perform unpack if compilation succeeded
       if (result.errorSummary.totalErrors === 0) {
         await performUnpack(pattern, destDir, this.cwd);
         successfulOutputDirs.push(destDir);
       }
 
+      // Fsync all output directories to force XFS metadata commit
+      // before the next compilation step. Without this, XFS delayed logging
+      // can cause directory entries from previous compilations to become
+      // invisible or corrupted during subsequent TypeScript emit operations.
+      for (const dir of successfulOutputDirs) {
+        try {
+          const fd = fs.openSync(dir, 'r');
+          fs.fsyncSync(fd);
+          fs.closeSync(fd);
+        } catch {
+          // Directory might not exist yet
+        }
+      }
+
+      // 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 +496,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

@@ -122,10 +122,13 @@ export class FsHelpers {
   }
 
   /**
-   * Remove a directory recursively
+   * Remove a directory recursively.
+   * Uses synchronous rm to avoid XFS metadata corruption observed with
+   * async fs.promises.rm affecting sibling directory entries on the
+   * libuv thread pool under signal pressure.
    */
   public static async removeDirectory(dirPath: string): Promise<void> {
-    await fs.promises.rm(dirPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    fs.rmSync(dirPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   }
 
   /**

ts/mod_unpack/classes.tsunpacker.ts

@@ -90,9 +90,9 @@ export class TsUnpacker {
    * 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.
+   * 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.
    */
@@ -107,25 +107,40 @@ export class TsUnpacker {
 
     const nestedPath = this.getNestedPath();
 
+    // Force XFS to flush pending directory metadata before reading.
+    // XFS delayed logging (CIL) can defer metadata commits, causing
+    // readdirSync/opendirSync to return incomplete results immediately
+    // after TypeScript's emit() creates files via writeFileSync.
+    const destFd = fs.openSync(this.destDir, 'r');
+    fs.fsyncSync(destFd);
+    fs.closeSync(destFd);
+    const nestedFd = fs.openSync(nestedPath, 'r');
+    fs.fsyncSync(nestedFd);
+    fs.closeSync(nestedFd);
+
     // Step 1: Remove sibling entries (everything in dest except the source folder)
-    const destEntries = await fs.promises.readdir(this.destDir);
+    const destEntries = fs.readdirSync(this.destDir);
     for (const entry of destEntries) {
       if (entry !== this.sourceFolderName) {
-        await fs.promises.rm(path.join(this.destDir, entry), { recursive: true, force: true });
+        fs.rmSync(path.join(this.destDir, entry), { recursive: true, force: true });
       }
     }
 
     // Step 2: Move all contents from nested dir up to dest dir
-    const nestedEntries = await fs.promises.readdir(nestedPath);
+    const nestedEntries = fs.readdirSync(nestedPath);
     for (const entry of nestedEntries) {
-      await fs.promises.rename(
+      fs.renameSync(
         path.join(nestedPath, entry),
         path.join(this.destDir, entry),
       );
     }
 
     // Step 3: Remove the now-empty nested directory
-    await fs.promises.rmdir(nestedPath);
+    fs.rmdirSync(nestedPath);
+
+    // Diagnostic: verify final state
+    const finalEntries = fs.readdirSync(this.destDir);
+    console.log(`   📦 Unpacked ${this.sourceFolderName}: moved ${nestedEntries.length} entries, final: ${finalEntries.length} entries`);
 
     return true;
   }