v4.2.4

changelog.md

@@ -1,5 +1,64 @@
 # Changelog
 
+## 2026-03-05 - 4.2.4 - fix(fshelpers)
+remove outdated comment about using synchronous rm to avoid XFS metadata corruption
+
+- Comment-only change in ts/mod_fs/classes.fshelpers.ts; no runtime or API behavior changes
+- Bump patch version from 4.2.3 to 4.2.4
+
+## 2026-03-05 - 4.2.3 - fix(compiler)
+defer unpacking until after all compilations and remove diagnostic filesystem syncs to avoid XFS metadata visibility issues
+
+- Queue pending unpack operations during compilation and run them after all compile tasks complete to avoid modifying output directories while other compilations are writing.
+- Remove TypeScript sys interception, execSync('sync') calls, and per-unpack fs.fsyncSync usage that attempted to work around XFS delayed metadata commits; rely on performing all unpacks after compilation instead.
+- Clean up noisy diagnostic code (external 'ls' comparisons, readdir snapshots) and simplify logging of unpack results.
+- Remove unused imports (fs and child_process.execSync) from the compiler module.
+
+## 2026-03-05 - 4.2.2 - fix(compiler)
+force global filesystem sync to flush XFS delayed logging and add diagnostics comparing Node's readdirSync with system ls to detect directory entry inconsistencies
+
+- Replace per-directory fs.fsyncSync loop with execSync('sync') to ensure parent B+tree metadata is flushed on XFS
+- Import execSync from child_process
+- Add diagnostic comparison: run ls -1 and compare its entries to fs.readdirSync; log mismatches and full entry lists for debugging Node.js caching/readdir inconsistencies
+
+## 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
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsbuild",
-  "version": "4.1.23",
+  "version": "4.2.4",
   "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.23',
+  version: '4.2.4',
   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,6 +1,5 @@
 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';
@@ -325,6 +324,12 @@ export class TsCompiler {
       console.log('');
     }
 
+    // Collect unpack tasks to perform AFTER all compilations complete.
+    // This prevents filesystem metadata corruption on XFS where heavy write
+    // activity during subsequent compilations can make freshly-renamed entries
+    // in previously-unpacked directories invisible or lost.
+    const pendingUnpacks: Array<{ pattern: string; destDir: string }> = [];
+
     for (const pattern of Object.keys(globPatterns)) {
       const destPath = globPatterns[pattern];
       if (!pattern || !destPath) continue;
@@ -338,31 +343,13 @@ 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 = {
@@ -383,43 +370,19 @@ export class TsCompiler {
       const result = await this.compileFiles(absoluteFiles, options, taskInfo);
       emittedFiles.push(...result.emittedFiles);
       errorSummaries.push(result.errorSummary);
-      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
+      // Queue unpack for after all compilations (don't modify output dirs between compilations)
       if (result.errorSummary.totalErrors === 0) {
-        await performUnpack(pattern, destDir, this.cwd);
+        pendingUnpacks.push({ pattern, destDir });
         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!`);
-          }
-        }
-      }
-
+    // Perform all unpacks after all compilations are done.
+    // This ensures no output directory is modified while subsequent compilations
+    // are performing heavy filesystem writes to sibling directories.
+    for (const { pattern, destDir } of pendingUnpacks) {
+      await performUnpack(pattern, destDir, this.cwd);
     }
 
     // Rewrite import paths in all output directories to handle cross-module references
@@ -434,21 +397,6 @@ 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

@@ -123,9 +123,6 @@ export class FsHelpers {
 
   /**
    * 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> {
     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
    *
-   * 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).
+   * Uses synchronous fs operations for reliability.
+   * Called after all compilations are complete (not between compilations)
+   * to avoid filesystem metadata issues on XFS.
    *
    * Returns true if unpacking was performed, false if skipped.
    */
@@ -116,26 +116,18 @@ export class TsUnpacker {
     }
 
     // Step 2: Move all contents from nested dir up to dest dir
-    // Use a loop to handle any partial readdirSync results
-    let moved = 0;
-    while (true) {
-      const entries = fs.readdirSync(nestedPath);
-      if (entries.length === 0) break;
-      for (const entry of entries) {
-        fs.renameSync(
-          path.join(nestedPath, entry),
-          path.join(this.destDir, entry),
-        );
-        moved++;
-      }
+    const nestedEntries = fs.readdirSync(nestedPath);
+    for (const entry of nestedEntries) {
+      fs.renameSync(
+        path.join(nestedPath, entry),
+        path.join(this.destDir, entry),
+      );
     }
 
     // Step 3: Remove the now-empty nested directory
     fs.rmdirSync(nestedPath);
 
-    // Diagnostic: verify final state
-    const finalEntries = fs.readdirSync(this.destDir);
-    console.log(`   📦 Unpacked ${this.sourceFolderName}: moved ${moved} entries, final: ${finalEntries.length} entries`);
+    console.log(`   📦 Unpacked ${this.sourceFolderName}: ${nestedEntries.length} entries`);
 
     return true;
   }