v4.2.0

changelog.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 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
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsbuild",
-  "version": "4.1.22",
+  "version": "4.2.0",
   "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.22',
+  version: '4.2.0',
   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

@@ -380,9 +380,69 @@ export class TsCompiler {
         fileCount: absoluteFiles.length,
       };
 
+      // Diagnostic: intercept fs operations during compilation to detect
+      // any unexpected deletions in previously compiled output directories
+      const watchedDirs = successfulOutputDirs.filter(d => d !== destDir);
+      const origUnlink = fs.unlinkSync;
+      const origRm = fs.rmSync;
+      const origRmdir = fs.rmdirSync;
+      const origRename = fs.renameSync;
+      const origWriteFile = fs.writeFileSync;
+      let interceptedOps: string[] = [];
+      if (watchedDirs.length > 0 && !isQuiet && !isJson) {
+        (fs as any).unlinkSync = (p: string, ...args: any[]) => {
+          if (watchedDirs.some(d => String(p).startsWith(d + '/'))) {
+            interceptedOps.push(`unlink: ${p}`);
+          }
+          return origUnlink.call(fs, p, ...args);
+        };
+        (fs as any).rmSync = (p: string, ...args: any[]) => {
+          if (watchedDirs.some(d => String(p).startsWith(d + '/'))) {
+            interceptedOps.push(`rm: ${p}`);
+          }
+          return origRm.call(fs, p, ...args);
+        };
+        (fs as any).rmdirSync = (p: string, ...args: any[]) => {
+          if (watchedDirs.some(d => String(p).startsWith(d + '/'))) {
+            interceptedOps.push(`rmdir: ${p}`);
+          }
+          return origRmdir.call(fs, p, ...args);
+        };
+        (fs as any).renameSync = (src: string, dest: string, ...args: any[]) => {
+          if (watchedDirs.some(d => String(src).startsWith(d + '/') || String(dest).startsWith(d + '/'))) {
+            interceptedOps.push(`rename: ${src} → ${dest}`);
+          }
+          return origRename.call(fs, src, dest, ...args);
+        };
+        (fs as any).writeFileSync = (p: string, ...args: any[]) => {
+          if (watchedDirs.some(d => String(p).startsWith(d + '/'))) {
+            interceptedOps.push(`write: ${p}`);
+          }
+          return origWriteFile.call(fs, p, ...args);
+        };
+      }
+
       const result = await this.compileFiles(absoluteFiles, options, taskInfo);
       emittedFiles.push(...result.emittedFiles);
       errorSummaries.push(result.errorSummary);
+
+      // Restore original fs methods and report any intercepted operations
+      if (watchedDirs.length > 0 && !isQuiet && !isJson) {
+        (fs as any).unlinkSync = origUnlink;
+        (fs as any).rmSync = origRm;
+        (fs as any).rmdirSync = origRmdir;
+        (fs as any).renameSync = origRename;
+        (fs as any).writeFileSync = origWriteFile;
+        if (interceptedOps.length > 0) {
+          console.log(`   ⚠️ [diag] ${interceptedOps.length} ops on previous output dirs during compilation:`);
+          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`);
+          }
+        }
+      }
       diagSnap('post-compile');
 
       // Diagnostic: log emitted files that went to unexpected directories
@@ -405,6 +465,20 @@ export class TsCompiler {
         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) {

ts/mod_unpack/classes.tsunpacker.ts

@@ -107,6 +107,17 @@ 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 = fs.readdirSync(this.destDir);
     for (const entry of destEntries) {
@@ -127,6 +138,10 @@ export class TsUnpacker {
     // 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 ${nestedEntries.length} entries, final: ${finalEntries.length} entries`);
+
     return true;
   }
 }