v4.2.3

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,231 @@
 # Changelog
 
+## 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
+
+- Bumped dependencies: @git.zone/tspublish ^1.10.3 → ^1.11.0, @push.rocks/smartfs ^1.2.0 → ^1.3.1, @git.zone/tstest ^3.1.3 → ^3.1.4, @types/node ^25.0.1 → ^25.0.3
+- npmextra.json reorganized: replaced legacy keys with namespaced entries (@git.zone/cli, @git.zone/tsdoc) and added @ship.zone/szci; added release configuration with registries [https://verdaccio.lossless.digital, https://registry.npmjs.org] and public accessLevel
+- README rewritten: improved formatting, added emojis and tables, new 'Issue Reporting and Security' section, monorepo/tspublish usage docs, auto-unpack and decorator guidance, CI/CD and troubleshooting improvements
+- Non-breaking changes; recommended next semantic version bump is minor
+
+## 2025-12-14 - 4.0.2 - fix(TsCompiler)
+Clear output directories before compilation to ensure clean builds and avoid stale files
+
+- TsCompiler.compileGlob now clears the destination directory (if it exists) before compiling each glob pattern.
+- Clearing is logged unless --quiet or --json flags are set (e.g. "🧹 Clearing output directory: <dest>").
+- Uses FsHelpers.removeDirectory to remove previous output, preventing stale or duplicate emitted files.
+- Documentation (readme.md) updated to advertise automatic output directory management / clean builds.
+- Removed stale compiled test artifacts from test/assets/output to avoid interference with tests.
+
 ## 2025-12-13 - 3.1.3 - fix(npmextra)
 Align npmextra.json package name with package.json (@git.zone/tsbuild)
 

npmextra.json

@@ -1,9 +1,5 @@
 {
-  "npmci": {
-    "npmGlobalTools": [],
-    "npmAccessLevel": "public"
-  },
-  "gitzone": {
+  "@git.zone/cli": {
     "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
@@ -23,9 +19,19 @@
         "development",
         "API"
       ]
+    },
+    "release": {
+      "registries": [
+        "https://verdaccio.lossless.digital",
+        "https://registry.npmjs.org"
+      ],
+      "accessLevel": "public"
     }
   },
-  "tsdoc": {
+  "@git.zone/tsdoc": {
     "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  },
+  "@ship.zone/szci": {
+    "npmGlobalTools": []
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsbuild",
-  "version": "4.0.0",
+  "version": "4.2.3",
   "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.10.3",
+    "@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.2.0",
-    "@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.3",
-    "@types/node": "^25.0.1"
+    "@git.zone/tstest": "^3.2.0",
+    "@types/node": "^25.3.3"
   },
   "files": [
     "ts/**/*",

test/assets/output/tocompile.d.ts

@@ -1 +0,0 @@
-export {};

test/assets/output/tocompile.js

@@ -1,17 +0,0 @@
-console.log('test');
-console.log('test2');
-import * as early from '@push.rocks/early';
-early.start();
-early.stop();
-import { anExportedString } from './tocompile2.js';
-console.log(anExportedString);
-class test2 {
-    test = [];
-    constructor() {
-        console.log('hi');
-    }
-}
-const run = async () => {
-    return 'hi';
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9jb21waWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdG9jb21waWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDcEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUVyQixPQUFPLEtBQUssS0FBSyxNQUFNLG1CQUFtQixDQUFDO0FBRTNDLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztBQUNkLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQztBQUViLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ25ELE9BQU8sQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztBQUU5QixNQUFNLEtBQUs7SUFDVCxJQUFJLEdBQWEsRUFBRSxDQUFDO0lBQ3BCO1FBQ0UsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNwQixDQUFDO0NBQ0Y7QUFFRCxNQUFNLEdBQUcsR0FBRyxLQUFLLElBQXFCLEVBQUU7SUFDdEMsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDLENBQUMifQ==

test/assets/output/tocompile2.d.ts

@@ -1 +0,0 @@
-export declare const anExportedString = "exported string";

test/assets/output/tocompile2.js

@@ -1,3 +0,0 @@
-console.log('hello');
-export const anExportedString = 'exported string';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9jb21waWxlMi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RvY29tcGlsZTIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUNyQixNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxpQkFBaUIsQ0FBQyJ9

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tsbuild',
-  version: '3.1.3',
+  version: '4.2.3',
   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
@@ -307,6 +308,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 +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;
@@ -335,10 +343,19 @@ export class TsCompiler {
       // 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}`);
+        }
+        await FsHelpers.removeDirectory(destDir);
+      }
+
       // Update compiler options with the output directory
       const options: CompilerOptions = {
         ...customOptions,
         outDir: destDir,
+        listEmittedFiles: true,
       };
 
       currentTask++;
@@ -354,9 +371,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,13 @@ export class FsHelpers {
   }
 
   /**
-   * Remove a directory recursively
+   * 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> {
-    await fs.promises.rm(dirPath, { recursive: true });
+    fs.rmSync(dirPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   }
 
   /**
@@ -134,11 +137,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;
   }
 }