v4.2.6

Restructured compileGlob() into three distinct phases:
1. Resolve glob patterns and clean ALL output directories upfront
2. Compile all TypeScript tasks (no filesystem cleanup during this phase)
3. Unpack all outputs after all compilations complete

This prevents XFS metadata corruption from rm operations overlapping
with TypeScript compilation writes to sibling directories.

changelog.md

@@ -1,5 +1,211 @@
 # Changelog
 
+## 2026-03-05 - 4.2.6 - fix(meta)
+no changes
+
+- Current package version: 4.2.5
+- No code or file changes detected in this commit; no release required
+
+## 2026-03-05 - 4.2.5 - fix(compiler)
+yield to the event loop after TypeScript emit to allow pending microtasks and I/O to settle before reading or modifying the output directory
+
+- Added await new Promise(resolve => process.nextTick(resolve)) immediately after program.emit()
+- Prevents race conditions by allowing libuv write completions and other deferred callbacks to complete before accessing the output directory
+- File changed: ts/mod_compiler/classes.tscompiler.ts
+
+## 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
+
+- 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
+
+- 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
+
+- move(): use fs.renameSync to improve reliability on XFS/mounted filesystems where async rename can be interrupted by process managers
+- removeEmptyDirectory(): retry fs.promises.rmdir up to 5 attempts with incremental delays; return on ENOENT; avoid recursive rm on ENOTEMPTY to prevent removing still-valid references
+- Dependency bump: @push.rocks/smartfs from ^1.3.1 to ^1.3.2
+
+## 2026-03-05 - 4.1.8 - fix(unpack)
+catch unpack errors and add verbose unpack logging
+
+- Wrap performUnpack call in the compiler to catch and log exceptions so unpack failures don't crash the process
+- Log the number of directories and files being unpacked when moving nested contents to aid debugging
+
+## 2026-03-05 - 4.1.7 - fix(fs/compiler/unpack)
+robustify directory removal and remove noisy diagnostic logging
+
+- Use fs.promises.rm with force, maxRetries and retryDelay in removeDirectory to reduce intermittent failures during removals.
+- Handle ENOTEMPTY in removeEmptyDirectory by falling back to a recursive rm and ignore ENOENT to avoid errors from transient filesystem metadata lag.
+- Remove several diagnostic/verbose console logs in the compiler and unpacker paths to reduce noisy output and simplify flow.
+- Short-circuit unpack logic when no nesting is detected to avoid unnecessary work and logs.
+- No public API or behavior-breaking changes; suitable for a patch release.
+
+## 2026-03-05 - 4.1.6 - fix(mod_compiler)
+add diagnostic logging to report dist_ts and output directory contents after each compilation task and after import-path rewriting
+
+- Adds DIAG-CROSSTASK logs to inspect dist_ts subdirectories after each task when not in quiet or JSON mode
+- Adds DIAG-FINAL logs to report directory names and file counts for each successful output dir after import-path rewriting
+- Diagnostics use dynamic fs import and are non-intrusive: gated by isQuiet/isJson and errors are ignored
+
 ## 2026-03-05 - 4.1.5 - fix(diagnostics)
 add diagnostic logging around compilation and unpack to aid troubleshooting
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsbuild",
-  "version": "4.1.5",
+  "version": "4.2.6",
   "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",
@@ -41,7 +41,7 @@
     "@push.rocks/smartcli": "^4.0.20",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartfile": "^13.1.2",
-    "@push.rocks/smartfs": "^1.3.1",
+    "@push.rocks/smartfs": "^1.3.2",
     "@push.rocks/smartlog": "^3.2.1",
     "@push.rocks/smartpath": "^6.0.0",
     "@push.rocks/smartpromise": "^4.2.3",

pnpm-lock.yaml

@@ -24,8 +24,8 @@ importers:
         specifier: ^13.1.2
         version: 13.1.2
       '@push.rocks/smartfs':
-        specifier: ^1.3.1
-        version: 1.3.1
+        specifier: ^1.3.2
+        version: 1.3.2
       '@push.rocks/smartlog':
         specifier: ^3.2.1
         version: 3.2.1
@@ -973,8 +973,8 @@ packages:
   '@push.rocks/smartfile@13.1.2':
     resolution: {integrity: sha512-DaEhwmnGEpX4coeeToaw4cZe3pNBhH7CY1iGr+d3pIXihozREvzzAR9/0i2r7bUXXL5+Lgy8YYIk5ZS+fwxMKA==}
 
-  '@push.rocks/smartfs@1.3.1':
-    resolution: {integrity: sha512-ZSduVS8tM+/erbyCTvRRvc9gLWwbpqN5xdIIkMr+gub7fowSeJb7tR2rnGwySa63DyimU0q2KTp79VV9YqGLeg==}
+  '@push.rocks/smartfs@1.3.2':
+    resolution: {integrity: sha512-Fpr4O4xb5DUMBjmgUr3TCimmt6tAjCAPefUU2isV5xexbZS0vhBNiB2GehhuvAXmXDrbQcsTgd8hs6ags6SDog==}
 
   '@push.rocks/smartguard@3.1.0':
     resolution: {integrity: sha512-J23q84f1O+TwFGmd4lrO9XLHUh2DaLXo9PN/9VmTWYzTkQDv5JehmifXVI0esophXcCIfbdIu6hbt7/aHlDF4A==}
@@ -3991,7 +3991,7 @@ snapshots:
       '@push.rocks/smartenv': 6.0.0
       '@push.rocks/smartfeed': 1.4.0
       '@push.rocks/smartfile': 13.1.2
-      '@push.rocks/smartfs': 1.3.1
+      '@push.rocks/smartfs': 1.3.2
       '@push.rocks/smartjson': 5.2.0
       '@push.rocks/smartlog': 3.2.1
       '@push.rocks/smartlog-destination-devtools': 1.0.12
@@ -4870,7 +4870,7 @@ snapshots:
       '@push.rocks/npmextra': 5.3.3
       '@push.rocks/smartcli': 4.0.20
       '@push.rocks/smartdelay': 3.0.5
-      '@push.rocks/smartfs': 1.3.1
+      '@push.rocks/smartfs': 1.3.2
       '@push.rocks/smartinteract': 2.0.16
       '@push.rocks/smartlog': 3.2.1
       '@push.rocks/smartlog-destination-local': 9.0.2
@@ -4897,7 +4897,7 @@ snapshots:
       '@push.rocks/smartcli': 4.0.20
       '@push.rocks/smartdelay': 3.0.5
       '@push.rocks/smartfile': 13.1.2
-      '@push.rocks/smartfs': 1.3.1
+      '@push.rocks/smartfs': 1.3.2
       '@push.rocks/smartlog': 3.2.1
       '@push.rocks/smartnpm': 2.0.6
       '@push.rocks/smartpath': 6.0.0
@@ -4931,7 +4931,7 @@ snapshots:
       '@push.rocks/smartenv': 6.0.0
       '@push.rocks/smartexpect': 2.5.0
       '@push.rocks/smartfile': 13.1.2
-      '@push.rocks/smartfs': 1.3.1
+      '@push.rocks/smartfs': 1.3.2
       '@push.rocks/smartjson': 6.0.0
       '@push.rocks/smartlog': 3.2.1
       '@push.rocks/smartmongo': 5.1.0(socks@2.8.7)
@@ -5610,7 +5610,7 @@ snapshots:
       '@push.rocks/lik': 6.2.2
       '@push.rocks/smartdelay': 3.0.5
       '@push.rocks/smartfile-interfaces': 1.0.7
-      '@push.rocks/smartfs': 1.3.1
+      '@push.rocks/smartfs': 1.3.2
       '@push.rocks/smarthash': 3.2.6
       '@push.rocks/smartjson': 5.2.0
       '@push.rocks/smartmime': 2.0.4
@@ -5622,7 +5622,7 @@ snapshots:
       glob: 11.1.0
       js-yaml: 4.1.1
 
-  '@push.rocks/smartfs@1.3.1':
+  '@push.rocks/smartfs@1.3.2':
     dependencies:
       '@push.rocks/smartpath': 6.0.0
 
@@ -5721,7 +5721,7 @@ snapshots:
     dependencies:
       '@push.rocks/mongodump': 1.1.0(socks@2.8.7)
       '@push.rocks/smartdata': 5.16.7(socks@2.8.7)
-      '@push.rocks/smartfs': 1.3.1
+      '@push.rocks/smartfs': 1.3.2
       '@push.rocks/smartpath': 5.1.0
       '@push.rocks/smartpromise': 4.2.3
       '@push.rocks/smartrx': 3.0.10
@@ -5748,7 +5748,7 @@ snapshots:
     dependencies:
       '@push.rocks/mongodump': 1.1.0(socks@2.8.7)
       '@push.rocks/smartdata': 5.16.7(socks@2.8.7)
-      '@push.rocks/smartfs': 1.3.1
+      '@push.rocks/smartfs': 1.3.2
       '@push.rocks/smartpath': 5.1.0
       '@push.rocks/smartpromise': 4.2.3
       '@push.rocks/smartrx': 3.0.10

ts/00_commitinfo_data.ts

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

@@ -244,6 +244,12 @@ export class TsCompiler {
 
     // If no pre-emit errors, proceed with emit
     const emitResult = program.emit();
+
+    // Yield to the event loop so any pending microtasks, nextTick callbacks,
+    // or deferred I/O from TypeScript's emit (e.g. libuv write completions)
+    // can settle before we read or modify the output directory.
+    await new Promise<void>((resolve) => process.nextTick(resolve));
+
     const emitErrorSummary = this.processDiagnostics(emitResult.diagnostics);
 
     // Combine error summaries
@@ -324,20 +330,25 @@ export class TsCompiler {
       console.log('');
     }
 
+    // Phase 1: Resolve glob patterns and clean ALL output directories upfront.
+    // This ensures no rm/rmSync activity overlaps with TypeScript compilation,
+    // preventing XFS metadata corruption from concurrent metadata operations.
+    interface IResolvedTask {
+      pattern: string;
+      destPath: string;
+      destDir: string;
+      absoluteFiles: string[];
+    }
+    const resolvedTasks: IResolvedTask[] = [];
+
     for (const pattern of Object.keys(globPatterns)) {
       const destPath = globPatterns[pattern];
       if (!pattern || !destPath) continue;
 
-      // Get files matching the glob pattern
       const files = await FsHelpers.listFilesWithGlob(this.cwd, pattern);
-
-      // Transform to absolute paths
       const absoluteFiles = smartpath.transform.toAbsolute(files, this.cwd) as string[];
-
-      // Get destination directory as absolute path
       const destDir = smartpath.transform.toAbsolute(destPath, this.cwd) as string;
 
-      // Clear the destination directory before compilation if it exists
       if (await FsHelpers.directoryExists(destDir)) {
         if (!isQuiet && !isJson) {
           console.log(`🧹 Clearing output directory: ${destPath}`);
@@ -345,10 +356,16 @@ export class TsCompiler {
         await FsHelpers.removeDirectory(destDir);
       }
 
-      // Update compiler options with the output directory
+      resolvedTasks.push({ pattern, destPath, destDir, absoluteFiles });
+    }
+
+    // Phase 2: Compile all tasks. No filesystem cleanup happens during this phase.
+    const pendingUnpacks: Array<{ pattern: string; destDir: string }> = [];
+
+    for (const task of resolvedTasks) {
       const options: CompilerOptions = {
         ...customOptions,
-        outDir: destDir,
+        outDir: task.destDir,
         listEmittedFiles: true,
       };
 
@@ -356,44 +373,26 @@ export class TsCompiler {
       const taskInfo: ITaskInfo = {
         taskNumber: currentTask,
         totalTasks,
-        sourcePattern: pattern,
-        destDir: destPath,
-        fileCount: absoluteFiles.length,
+        sourcePattern: task.pattern,
+        destDir: task.destPath,
+        fileCount: task.absoluteFiles.length,
       };
 
-      const result = await this.compileFiles(absoluteFiles, options, taskInfo);
+      const result = await this.compileFiles(task.absoluteFiles, options, taskInfo);
       emittedFiles.push(...result.emittedFiles);
       errorSummaries.push(result.errorSummary);
 
-      // DIAGNOSTIC: Log directory contents after compilation
-      if (!isQuiet && !isJson) {
-        try {
-          const fs = await import('fs');
-          const dirEntries = fs.readdirSync(destDir, { withFileTypes: true });
-          const dirs = dirEntries.filter((e: any) => e.isDirectory()).map((e: any) => e.name).sort();
-          const fileCount = dirEntries.filter((e: any) => e.isFile()).length;
-          console.log(`   📋 [DIAG] After emit: ${dirs.length} dirs [${dirs.join(', ')}], ${fileCount} top-level files`);
-          console.log(`   📋 [DIAG] emittedFiles.length=${result.emittedFiles.length}, totalErrors=${result.errorSummary.totalErrors}`);
-        } catch (e: any) { console.log(`   📋 [DIAG] Error reading destDir: ${e.message}`); }
-      }
-
-      // Perform unpack if compilation succeeded
       if (result.errorSummary.totalErrors === 0) {
+        pendingUnpacks.push({ pattern: task.pattern, destDir: task.destDir });
+        successfulOutputDirs.push(task.destDir);
+      }
+    }
+
+    // Phase 3: 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);
-
-        // DIAGNOSTIC: Log directory contents after unpack
-        if (!isQuiet && !isJson) {
-          try {
-            const fs = await import('fs');
-            const dirEntries = fs.readdirSync(destDir, { withFileTypes: true });
-            const dirs = dirEntries.filter((e: any) => e.isDirectory()).map((e: any) => e.name).sort();
-            const fileCount = dirEntries.filter((e: any) => e.isFile()).length;
-            console.log(`   📋 [DIAG] After unpack: ${dirs.length} dirs [${dirs.join(', ')}], ${fileCount} top-level files`);
-          } catch (e: any) { console.log(`   📋 [DIAG] Error reading destDir after unpack: ${e.message}`); }
-        }
-
-        successfulOutputDirs.push(destDir);
-      }
     }
 
     // Rewrite import paths in all output directories to handle cross-module references

ts/mod_fs/classes.fshelpers.ts

@@ -122,10 +122,10 @@ export class FsHelpers {
   }
 
   /**
-   * Remove a directory recursively
+   * Remove a directory recursively.
    */
   public static async removeDirectory(dirPath: string): Promise<void> {
-    await fs.promises.rm(dirPath, { recursive: true });
+    fs.rmSync(dirPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   }
 
   /**
@@ -134,11 +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> {
-    await fs.promises.rmdir(dirPath);
-  }
 }

ts/mod_unpack/classes.tsunpacker.ts

@@ -81,73 +81,56 @@ 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
+   *
+   * 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.
    */
   public async unpack(): Promise<boolean> {
-    // Check if we should unpack based on config
     if (!(await this.shouldUnpack())) {
-      console.log(`   📋 [DIAG-UNPACK] Skipping unpack: shouldUnpack=false`);
       return false;
     }
 
-    // Check if nested structure exists
-    const hasNesting = await this.detectNesting();
-    console.log(`   📋 [DIAG-UNPACK] detectNesting=${hasNesting}, nestedPath=${this.getNestedPath()}`);
-    if (!hasNesting) {
+    if (!(await this.detectNesting())) {
       return false;
     }
 
     const nestedPath = this.getNestedPath();
 
-    // DIAGNOSTIC: Log contents before unpack
-    try {
-      const destEntries = fs.readdirSync(this.destDir, { withFileTypes: true });
-      const destDirs = destEntries.filter(e => e.isDirectory()).map(e => e.name).sort();
-      console.log(`   📋 [DIAG-UNPACK] Before removeSibling: destDir dirs=[${destDirs.join(', ')}]`);
-      const nestedEntries = fs.readdirSync(nestedPath, { withFileTypes: true });
-      const nestedDirs = nestedEntries.filter(e => e.isDirectory()).map(e => e.name).sort();
-      const nestedFiles = nestedEntries.filter(e => e.isFile()).length;
-      console.log(`   📋 [DIAG-UNPACK] Nested dir (${this.sourceFolderName}/): ${nestedDirs.length} dirs [${nestedDirs.join(', ')}], ${nestedFiles} files`);
-    } catch (e: any) { console.log(`   📋 [DIAG-UNPACK] Error reading: ${e.message}`); }
+    // Step 1: Remove sibling entries (everything in dest except the source folder)
+    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 });
+      }
+    }
 
-    // Delete sibling folders (not the source folder)
-    await this.removeSiblingDirectories();
+    // Step 2: Move all contents from nested dir up to dest dir
+    const nestedEntries = fs.readdirSync(nestedPath);
+    for (const entry of nestedEntries) {
+      fs.renameSync(
+        path.join(nestedPath, entry),
+        path.join(this.destDir, entry),
+      );
+    }
 
-    // Move contents from nested folder up
-    await this.moveNestedContentsUp();
+    // Step 3: Remove the now-empty nested directory
+    fs.rmdirSync(nestedPath);
 
-    // Remove empty nested folder
-    await FsHelpers.removeEmptyDirectory(nestedPath);
+    console.log(`   📦 Unpacked ${this.sourceFolderName}: ${nestedEntries.length} entries`);
 
     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);
-    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);
-    }
-  }
 }
 
 /**