v4.1.13

Previously only mapped folders from the current compilation glob patterns.
Now scans project directory for all ts_* folders to ensure imports like
'../ts_shared/' are rewritten to '../dist_ts_shared/' even when compiling
only the main ts/ folder.

changelog.md

@@ -1,5 +1,88 @@
 # Changelog
 
+## 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
+
+- Enable TypeScript CompilerOptions.listEmittedFiles to surface emitted file info
+- Log destination directory contents and emitted file/error counts after compile and after unpack (only when not quiet and not json)
+- Add unpack-specific diagnostic logs: shouldUnpack skip, detectNesting result and nestedPath, and nested/destination directory listings before removing sibling directories
+- All logs use console.log and are wrapped in try/catch to avoid throwing; changes are informational and non-breaking
+
+## 2026-03-05 - 4.1.4 - fix(deps)
+bump @git.zone/tspublish dependency to ^1.11.2
+
+- Updated @git.zone/tspublish from ^1.11.0 to ^1.11.2 in package.json
+
+## 2026-03-04 - 4.1.3 - fix(deps)
+bump dependencies: @push.rocks/smartcli, @push.rocks/smartlog, @git.zone/tstest, and @types/node to their newer versions
+
+- @push.rocks/smartcli: ^4.0.19 -> ^4.0.20
+- @push.rocks/smartlog: ^3.1.10 -> ^3.2.1
+- @git.zone/tstest: ^3.1.4 -> ^3.2.0
+- @types/node: ^25.0.3 -> ^25.3.3
+- Non-breaking dependency version bumps
+
 ## 2026-01-04 - 4.1.0 - feat(docs)
 update README with improved docs and monorepo/tspublish guidance; namespace and extend npmextra.json with release registries; bump several dependencies
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsbuild",
-  "version": "4.1.1",
+  "version": "4.1.13",
   "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",
@@ -36,21 +36,21 @@
   },
   "homepage": "https://code.foss.global/git.zone/tsbuild#README",
   "dependencies": {
-    "@git.zone/tspublish": "^1.11.0",
+    "@git.zone/tspublish": "^1.11.2",
     "@push.rocks/early": "^4.0.4",
-    "@push.rocks/smartcli": "^4.0.19",
+    "@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/smartlog": "^3.1.10",
+    "@push.rocks/smartfs": "^1.3.2",
+    "@push.rocks/smartlog": "^3.2.1",
     "@push.rocks/smartpath": "^6.0.0",
     "@push.rocks/smartpromise": "^4.2.3",
     "typescript": "5.9.3"
   },
   "devDependencies": {
     "@git.zone/tsrun": "^2.0.1",
-    "@git.zone/tstest": "^3.1.4",
-    "@types/node": "^25.0.3"
+    "@git.zone/tstest": "^3.2.0",
+    "@types/node": "^25.3.3"
   },
   "files": [
     "ts/**/*",

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tsbuild',
-  version: '4.1.0',
+  version: '4.1.13',
   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,8 @@
 import type { CompilerOptions, Diagnostic, Program } from 'typescript';
 import typescript from 'typescript';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartpath from '@push.rocks/smartpath';
@@ -349,6 +352,7 @@ export class TsCompiler {
       const options: CompilerOptions = {
         ...customOptions,
         outDir: destDir,
+        listEmittedFiles: true,
       };
 
       currentTask++;
@@ -366,15 +370,28 @@ export class TsCompiler {
 
       // Perform unpack if compilation succeeded
       if (result.errorSummary.totalErrors === 0) {
-        await performUnpack(pattern, destDir, this.cwd);
+        // Force XFS to commit all pending directory entries before unpacking.
+        // TypeScript's writeFileSync creates entries that may reside in XFS's
+        // delayed log. Without sync, readdir can return partial results.
+        execSync('sync');
+        this.syncDirectoryTree(destDir);
+
+        try {
+          await performUnpack(pattern, destDir, this.cwd);
+        } catch (unpackErr: any) {
+          console.error(`   ⚠️ Unpack error for ${destPath}: ${unpackErr.message}`);
+        }
+
         successfulOutputDirs.push(destDir);
       }
+
     }
 
     // Rewrite import paths in all output directories to handle cross-module references
     // This must happen after ALL compilations so all destination folders exist
+    // Use fromProjectDirectory to detect ALL ts_* folders, not just the ones being compiled
     if (successfulOutputDirs.length > 0) {
-      const rewriter = TsPathRewriter.fromGlobPatterns(globPatterns);
+      const rewriter = await TsPathRewriter.fromProjectDirectory(this.cwd);
       let totalRewritten = 0;
       for (const outputDir of successfulOutputDirs) {
         totalRewritten += await rewriter.rewriteDirectory(outputDir);
@@ -487,6 +504,27 @@ export class TsCompiler {
     return success;
   }
 
+  /**
+   * Recursively fsync all directories in a tree.
+   * Forces XFS to commit pending directory entries from its log.
+   */
+  private syncDirectoryTree(dirPath: string): void {
+    try {
+      const fd = fs.openSync(dirPath, 'r');
+      fs.fsyncSync(fd);
+      fs.closeSync(fd);
+
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          this.syncDirectoryTree(path.join(dirPath, entry.name));
+        }
+      }
+    } catch {
+      // Ignore errors (directory may not exist)
+    }
+  }
+
   /**
    * Merge multiple error summaries into one
    */

ts/mod_fs/classes.fshelpers.ts

@@ -125,7 +125,7 @@ export class FsHelpers {
    * Remove a directory recursively
    */
   public static async removeDirectory(dirPath: string): Promise<void> {
-    await fs.promises.rm(dirPath, { recursive: true });
+    await fs.promises.rm(dirPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   }
 
   /**
@@ -139,6 +139,29 @@ export class FsHelpers {
    * Remove an empty directory
    */
   public static async removeEmptyDirectory(dirPath: string): Promise<void> {
-    await fs.promises.rmdir(dirPath);
+    // 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_pathrewrite/classes.tspathrewriter.ts

@@ -51,6 +51,39 @@ export class TsPathRewriter {
     return new TsPathRewriter(mappings);
   }
 
+  /**
+   * Create a TsPathRewriter by auto-detecting all ts_* folders in the project directory.
+   * This ensures that cross-module imports are rewritten even when compiling a single module.
+   *
+   * For example, if the project has ts/, ts_shared/, ts_web/ folders:
+   * - ts → dist_ts
+   * - ts_shared → dist_ts_shared
+   * - ts_web → dist_ts_web
+   *
+   * @param cwd - The project root directory
+   * @returns TsPathRewriter instance with all detected folder mappings
+   */
+  public static async fromProjectDirectory(cwd: string): Promise<TsPathRewriter> {
+    const mappings: IFolderMapping[] = [];
+
+    try {
+      const entries = await FsHelpers.listDirectory(cwd);
+
+      for (const entry of entries) {
+        // Match folders starting with 'ts' (ts, ts_shared, ts_web, ts_core, etc.)
+        if (entry.isDirectory && /^ts(_|$)/.test(entry.name)) {
+          const sourceFolder = entry.name;
+          const destFolder = `dist_${sourceFolder}`;
+          mappings.push({ sourceFolder, destFolder });
+        }
+      }
+    } catch {
+      // Directory listing failed, return empty mappings
+    }
+
+    return new TsPathRewriter(mappings);
+  }
+
   /**
    * Get the current folder mappings
    */

ts/mod_unpack/classes.tsunpacker.ts

@@ -1,5 +1,5 @@
-import * as fs from 'fs';
 import * as path from 'path';
+import { execSync } from 'child_process';
 import { TsPublishConfig } from '../mod_config/index.js';
 import { FsHelpers } from '../mod_fs/index.js';
 
@@ -81,59 +81,36 @@ 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.
+   *
+   * Uses shell commands (mv, rm) via execSync for reliability. Node.js async
+   * fs operations (rename, rm) can race on XFS filesystems where metadata
+   * commits are delayed, causing ENOENT or partial directory listings.
+   * Shell commands execute as direct syscalls without libuv's async layer.
+   *
+   * 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())) {
       return false;
     }
 
-    // Check if nested structure exists
     if (!(await this.detectNesting())) {
       return false;
     }
 
     const nestedPath = this.getNestedPath();
+    const tempPath = this.destDir + '.__unpack_temp__';
 
-    // Delete sibling folders (not the source folder)
-    await this.removeSiblingDirectories();
-
-    // Move contents from nested folder up
-    await this.moveNestedContentsUp();
-
-    // Remove empty nested folder
-    await FsHelpers.removeEmptyDirectory(nestedPath);
+    // Use shell commands for atomic, sequential filesystem operations.
+    // This avoids race conditions between Node.js async fs operations on XFS.
+    execSync(`rm -rf "${tempPath}"`, { stdio: 'ignore' });
+    execSync(`mv "${nestedPath}" "${tempPath}"`, { stdio: 'ignore' });
+    execSync(`rm -rf "${this.destDir}"`, { stdio: 'ignore' });
+    execSync(`mv "${tempPath}" "${this.destDir}"`, { stdio: 'ignore' });
 
     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);
-    }
-  }
 }
 
 /**