v4.2.5

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,227 @@
 # Changelog
 
+## 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
+
+- 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.0",
+  "version": "4.2.5",
   "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.2.5',
   description: 'A tool for compiling TypeScript files using the latest nightly features, offering flexible APIs and a CLI for streamlined development.'
 }

ts/index.ts

@@ -5,6 +5,7 @@ early.start('tsbuild');
 export * from './mod_fs/index.js';
 export * from './mod_config/index.js';
 export * from './mod_unpack/index.js';
+export * from './mod_pathrewrite/index.js';
 export * from './mod_compiler/index.js';
 export * from './mod_cli/index.js';
 

ts/mod_compiler/classes.tscompiler.ts

@@ -7,6 +7,7 @@ import * as smartpath from '@push.rocks/smartpath';
 import { TsConfig } from '../mod_config/index.js';
 import { FsHelpers } from '../mod_fs/index.js';
 import { performUnpack } from '../mod_unpack/index.js';
+import { TsPathRewriter } from '../mod_pathrewrite/index.js';
 
 /**
  * Interface for error summary data
@@ -243,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
@@ -307,6 +314,7 @@ export class TsCompiler {
   ): Promise<ICompileResult> {
     const emittedFiles: string[] = [];
     const errorSummaries: IErrorSummary[] = [];
+    const successfulOutputDirs: string[] = [];
 
     const totalTasks = Object.keys(globPatterns).length;
     let currentTask = 0;
@@ -322,6 +330,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;
@@ -347,6 +361,7 @@ export class TsCompiler {
       const options: CompilerOptions = {
         ...customOptions,
         outDir: destDir,
+        listEmittedFiles: true,
       };
 
       currentTask++;
@@ -362,9 +377,31 @@ export class TsCompiler {
       emittedFiles.push(...result.emittedFiles);
       errorSummaries.push(result.errorSummary);
 
-      // 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);
+      }
+    }
+
+    // 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
+    // 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 = await TsPathRewriter.fromProjectDirectory(this.cwd);
+      let totalRewritten = 0;
+      for (const outputDir of successfulOutputDirs) {
+        totalRewritten += await rewriter.rewriteDirectory(outputDir);
+      }
+      if (totalRewritten > 0 && !isQuiet && !isJson) {
+        console.log(`   🔄 Rewrote import paths in ${totalRewritten} file${totalRewritten !== 1 ? 's' : ''}`);
       }
     }
 

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_pathrewrite/classes.tspathrewriter.ts

@@ -0,0 +1,233 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { FsHelpers } from '../mod_fs/index.js';
+
+/**
+ * Interface for folder mapping between source and destination
+ */
+export interface IFolderMapping {
+  sourceFolder: string;  // e.g., 'ts_shared'
+  destFolder: string;    // e.g., 'dist_ts_shared'
+}
+
+/**
+ * TsPathRewriter handles rewriting import paths in compiled JavaScript files.
+ *
+ * When TypeScript compiles files that import from sibling directories like:
+ *   import { helper } from '../ts_shared/helper.js';
+ *
+ * This class rewrites them to point to the compiled output directories:
+ *   import { helper } from '../dist_ts_shared/helper.js';
+ *
+ * This is necessary because the unpack feature flattens nested output structures,
+ * changing the relative paths between modules.
+ */
+export class TsPathRewriter {
+  private mappings: IFolderMapping[];
+
+  constructor(mappings: IFolderMapping[]) {
+    this.mappings = mappings;
+  }
+
+  /**
+   * Create a TsPathRewriter from glob patterns used in compilation
+   *
+   * @param globPatterns - Map of source patterns to destination directories
+   *   e.g., { './ts_core/**\/*.ts': './dist_ts_core', './ts_shared/**\/*.ts': './dist_ts_shared' }
+   * @returns TsPathRewriter instance with extracted folder mappings
+   */
+  public static fromGlobPatterns(globPatterns: Record<string, string>): TsPathRewriter {
+    const mappings: IFolderMapping[] = [];
+
+    for (const [sourcePattern, destDir] of Object.entries(globPatterns)) {
+      const sourceFolder = FsHelpers.extractSourceFolder(sourcePattern);
+      const destFolder = FsHelpers.extractSourceFolder(destDir);
+
+      if (sourceFolder && destFolder) {
+        mappings.push({ sourceFolder, destFolder });
+      }
+    }
+
+    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
+   */
+  public getMappings(): IFolderMapping[] {
+    return [...this.mappings];
+  }
+
+  /**
+   * Rewrite import paths in a single file
+   *
+   * @param filePath - Absolute path to the file to rewrite
+   * @returns true if file was modified, false otherwise
+   */
+  public async rewriteFile(filePath: string): Promise<boolean> {
+    // Only process .js and .d.ts files
+    if (!filePath.endsWith('.js') && !filePath.endsWith('.d.ts')) {
+      return false;
+    }
+
+    try {
+      const content = await fs.promises.readFile(filePath, 'utf8');
+      const rewritten = this.rewriteContent(content);
+
+      if (rewritten !== content) {
+        await fs.promises.writeFile(filePath, rewritten, 'utf8');
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      // File doesn't exist or other error
+      return false;
+    }
+  }
+
+  /**
+   * Rewrite import paths in all .js and .d.ts files in a directory (recursively)
+   *
+   * @param dirPath - Absolute path to the directory
+   * @returns Number of files modified
+   */
+  public async rewriteDirectory(dirPath: string): Promise<number> {
+    let modifiedCount = 0;
+
+    const processDir = async (currentDir: string): Promise<void> => {
+      const entries = await FsHelpers.listDirectory(currentDir);
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+
+        if (entry.isDirectory) {
+          await processDir(fullPath);
+        } else if (entry.isFile && (entry.name.endsWith('.js') || entry.name.endsWith('.d.ts'))) {
+          const wasModified = await this.rewriteFile(fullPath);
+          if (wasModified) {
+            modifiedCount++;
+          }
+        }
+      }
+    };
+
+    if (await FsHelpers.directoryExists(dirPath)) {
+      await processDir(dirPath);
+    }
+
+    return modifiedCount;
+  }
+
+  /**
+   * Rewrite import paths in content string
+   *
+   * This method only modifies actual import/export/require statements,
+   * not arbitrary strings or comments that might contain similar patterns.
+   *
+   * @param content - File content to process
+   * @returns Rewritten content
+   */
+  public rewriteContent(content: string): string {
+    if (this.mappings.length === 0) {
+      return content;
+    }
+
+    let result = content;
+
+    for (const { sourceFolder, destFolder } of this.mappings) {
+      // Skip if source and dest are the same
+      if (sourceFolder === destFolder) {
+        continue;
+      }
+
+      // Pattern 1: ES Module imports/exports with 'from'
+      // Matches: from '../ts_shared/...' or from '../../ts_shared/...'
+      // Also handles: export { x } from '../ts_shared/...'
+      const fromPattern = new RegExp(
+        `(from\\s*['"])((?:\\.\\.\\/)+)${this.escapeRegex(sourceFolder)}(\\/[^'"]*['"])`,
+        'g'
+      );
+      result = result.replace(fromPattern, `$1$2${destFolder}$3`);
+
+      // Pattern 2: Dynamic imports
+      // Matches: import('../ts_shared/...')
+      const dynamicImportPattern = new RegExp(
+        `(import\\s*\\(\\s*['"])((?:\\.\\.\\/)+)${this.escapeRegex(sourceFolder)}(\\/[^'"]*['"]\\s*\\))`,
+        'g'
+      );
+      result = result.replace(dynamicImportPattern, `$1$2${destFolder}$3`);
+
+      // Pattern 3: CommonJS require
+      // Matches: require('../ts_shared/...')
+      const requirePattern = new RegExp(
+        `(require\\s*\\(\\s*['"])((?:\\.\\.\\/)+)${this.escapeRegex(sourceFolder)}(\\/[^'"]*['"]\\s*\\))`,
+        'g'
+      );
+      result = result.replace(requirePattern, `$1$2${destFolder}$3`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Escape special regex characters in a string
+   */
+  private escapeRegex(str: string): string {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+}
+
+/**
+ * Convenience function to rewrite import paths in output directories
+ *
+ * @param globPatterns - Map of source patterns to destination directories
+ * @param outputDirs - List of output directories to process
+ * @returns Total number of files modified
+ */
+export async function rewriteImportPaths(
+  globPatterns: Record<string, string>,
+  outputDirs: string[]
+): Promise<number> {
+  const rewriter = TsPathRewriter.fromGlobPatterns(globPatterns);
+  let totalModified = 0;
+
+  for (const dir of outputDirs) {
+    totalModified += await rewriter.rewriteDirectory(dir);
+  }
+
+  return totalModified;
+}

ts/mod_pathrewrite/index.ts

@@ -0,0 +1 @@
+export * from './classes.tspathrewriter.js';

ts/mod_unpack/classes.tsunpacker.ts

@@ -81,58 +81,55 @@ 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())) {
       return false;
     }
 
-    // Check if nested structure exists
     if (!(await this.detectNesting())) {
       return false;
     }
 
     const nestedPath = this.getNestedPath();
 
-    // 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);
-
-    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));
+    // 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 });
       }
     }
-  }
 
-  /**
-   * 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);
+    // 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),
+      );
     }
+
+    // Step 3: Remove the now-empty nested directory
+    fs.rmdirSync(nestedPath);
+
+    console.log(`   📦 Unpacked ${this.sourceFolderName}: ${nestedEntries.length} entries`);
+
+    return true;
   }
 }