11.2.6

.gitea/workflows/default_nottags.yaml

@@ -6,8 +6,8 @@ on:
       - '**'
 
 env:
-  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
   NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
   NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
   NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
@@ -26,7 +26,7 @@ jobs:
       - name: Install pnpm and npmci
         run: |
           pnpm install -g pnpm
-          pnpm install -g @shipzone/npmci
+          pnpm install -g @ship.zone/npmci
 
       - name: Run npm prepare
         run: npmci npm prepare

.gitea/workflows/default_tags.yaml

@@ -6,8 +6,8 @@ on:
       - '*'
 
 env:
-  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
   NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
   NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
   NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
@@ -26,7 +26,7 @@ jobs:
       - name: Prepare
         run: |
           pnpm install -g pnpm
-          pnpm install -g @shipzone/npmci
+          pnpm install -g @ship.zone/npmci
           npmci npm prepare
 
       - name: Audit production dependencies
@@ -54,7 +54,7 @@ jobs:
       - name: Prepare
         run: |
           pnpm install -g pnpm
-          pnpm install -g @shipzone/npmci
+          pnpm install -g @ship.zone/npmci
           npmci npm prepare
 
       - name: Test stable
@@ -82,7 +82,7 @@ jobs:
       - name: Prepare
         run: |
           pnpm install -g pnpm
-          pnpm install -g @shipzone/npmci
+          pnpm install -g @ship.zone/npmci
           npmci npm prepare
 
       - name: Release
@@ -104,7 +104,7 @@ jobs:
       - name: Prepare
         run: |
           pnpm install -g pnpm
-          pnpm install -g @shipzone/npmci
+          pnpm install -g @ship.zone/npmci
           npmci npm prepare
 
       - name: Code quality

.gitignore

@@ -3,7 +3,6 @@
 # artifacts
 coverage/
 public/
-pages/
 
 # installs
 node_modules/
@@ -17,4 +16,8 @@ node_modules/
 dist/
 dist_*/
 
-# custom
+# AI
+.claude/
+.serena/
+
+#------# custom

.npmrc

@@ -0,0 +1 @@
+registry=https://registry.npmjs.org/

changelog.md

@@ -0,0 +1,470 @@
+# Changelog
+
+## 2025-08-18 - 11.2.6 - fix(fs)
+Improve fs and stream handling, enhance SmartFile/StreamFile, update tests and CI configs
+
+- Fix listFileTree to correctly handle '**/' patterns by running both root and nested patterns and deduplicating results.
+- Enhance waitForFileToBeReady: support directory paths (wait for first file) and improved file-stability checks with timeouts and retries.
+- StreamFile improvements: support Web ReadableStream -> Node Readable conversion, better multi-use buffering, more robust fromUrl/fromBuffer/fromStream implementations, and accurate byte-length computation.
+- SmartFile updates: switch fromUrl to SmartRequest, robust rename (optional on-disk rename), safer read/write paths and consistent Buffer handling for hashing and content edits.
+- fs module tweaks: copy/copySync gained replaceTargetDir option, improved toObjectSync error messages, toReadStream now validates existence, and various synchronous/async API consistency fixes.
+- memory module: consistent async/sync write APIs and smartfileArrayToFs formatting/behavior fixes.
+- fsstream: improved stream processing and SmartReadStream robustness (error handling, read logic and watcher improvements).
+- Tests: reformatted and strengthened tests (more explicit assertions, added tests for '**/*.ts' and '**/*' edge cases, updated imports to tapbundle usage).
+- CI/workflows: updated IMAGE and NPMCI_COMPUTED_REPOURL values and switched npmci package install to @ship.zone/npmci in workflow files.
+- package.json: bumped various dependencies, updated test script (timeout, logfile), added typings/main fields, homepage fix, pnpm overrides and minor metadata fixes.
+- .gitignore: added entries for AI tool folders (.claude/, .serena/).
+- Docs/readme: expanded README with clearer examples, features and TypeScript usage; updated readme hints for listFileTree behavior.
+
+## 2025-05-26 - 11.2.5 - fix(dev)
+
+Update dev dependencies and add local permission settings
+
+- Bump @git.zone/tsbuild from 2.5.2 to 2.6.4
+- Bump @git.zone/tstest from 1.9.0 to 2.2.5
+- Add .claude/settings.local.json to configure permissions for Bash(pnpm test:\*)
+
+## 2025-05-24 - 11.2.4 - fix(config)
+
+Add local permissions configuration for pnpm test commands in .claude/settings.local.json
+
+- Introduced .claude/settings.local.json to allow Bash(pnpm test:\*) permissions
+- Ensured local testing commands have proper execution rights
+
+## 2025-05-21 - 11.2.2 - fix(tests/settings)
+
+Improve test assertions and update local settings permissions
+
+- Refactor StreamFile tests to assert content string type using toBeTypeofString
+- Update file existence tests to use resolves.toBeTrue and resolves.toBeFalse for cleaner promise handling
+- Add .claude/settings.local.json to allow specific Bash permissions for pnpm test commands
+
+## 2025-05-21 - 11.2.1 - fix(fs)
+
+Fix inconsistent glob matching in listFileTree and update test imports and dependency versions for enhanced stability.
+
+- Enhanced listFileTree to support \*\*/ patterns by using dual patterns (root and nested) with deduplication.
+- Updated test imports to use '@git.zone/tstest/tapbundle' for consistency across test files.
+- Bumped dependency versions (@push.rocks/lik, smartpromise, smartrequest, glob) in package.json.
+- Added npm configuration (.npmrc) and local settings for improved test verbosity.
+
+## 2025-01-29 - 11.2.0 - feat(fs)
+
+Enhanced copy method with optional replaceTargetDir option for directory replacement
+
+- Added optional 'replaceTargetDir' option to 'copy' and 'copySync' methods in 'fs.ts'.
+- The 'replaceTargetDir' option allows replacing the target directory if both source and target are directories.
+
+## 2025-01-29 - 11.1.9 - fix(fs)
+
+Fix directory handling in copy and copySync functions
+
+- Ensured existing directories at destination are removed before copying over them in async copy.
+- Added a similar check and handling for synchronous copySync when destination is a directory.
+
+## 2025-01-29 - 11.1.8 - fix(fs)
+
+Fixed copy and copySync functions to ensure they always overwrite files.
+
+- Fixed bug in copy function where files were not being overwritten when they already existed at the destination.
+- Fixed bug in copySync function to ensure files are overwritten to match the async function's behavior.
+
+## 2025-01-29 - 11.1.7 - fix(fs)
+
+Refactor copy and copySync functions to simplify return type
+
+- Changed the return type of fs.copy and fs.copySync from boolean to void.
+- Removed unnecessary promise handling in fs.copy.
+
+## 2025-01-29 - 11.1.6 - fix(fs)
+
+Fix issues with fs file copy functions.
+
+- Updated dependencies in package.json.
+- Corrected comments for asynchronous and synchronous file copy functions in fs.ts.
+
+## 2025-01-07 - 11.1.5 - fix(fs)
+
+Improve waitForFileToBeReady function to handle directories and file stabilization
+
+- Enhanced the waitForFileToBeReady to handle directory paths by checking for file existence within directories and waiting for stabilization.
+- Modified the watcher logic to cater to changes when monitoring directories for file appearance.
+- Introduced a helper function to ensure paths exist and another to resolve the first file in directories.
+- Corrected logic for polling and stabilizing files within directories.
+
+## 2025-01-07 - 11.1.4 - fix(fs)
+
+Fix file existence check in waitForFileToBeReady method.
+
+- Ensured that the directory and file exist before setting up the watcher in waitForFileToBeReady.
+- Changed ensureDirectoryExists to ensureFileExists for correct file path verification.
+- Handled ENOENT errors correctly to retry file existence checks until timeout is reached.
+
+## 2025-01-07 - 11.1.3 - fix(fs)
+
+Fix TypeScript type issue in fs module
+
+- Corrected a TypeScript type in the fs module's checkFileStability function.
+
+## 2025-01-07 - 11.1.2 - fix(fs)
+
+Fix issues in file stability check and directory existence verification in fs module
+
+- Removed unused variable 'isFileAvailable' in 'waitForFileToBeReady'.
+- Fixed logic for ensuring the target directory exists before setting up file stability watcher.
+- Refactored directory existence logic into 'ensureDirectoryExists' function.
+
+## 2025-01-07 - 11.1.1 - fix(fs)
+
+Improve waitForFileToBeReady function for file stability detection
+
+- Enhanced error handling and file stability checks in waitForFileToBeReady function
+- Added timeout feature for file readiness check
+- Improved directory access check before file availability check
+
+## 2025-01-07 - 11.1.0 - feat(SmartFile)
+
+Add rename functionality to SmartFile class
+
+- Implemented a new method to rename a file within the SmartFile class.
+- The rename method updates the file path and optionally writes the renamed file to the disk.
+
+## 2024-12-15 - 11.0.23 - fix(fs)
+
+Handle errors in toObjectSync method
+
+- Added error handling in toObjectSync function to capture and provide more informative error messages.
+
+## 2024-06-23 - 11.0.22 - fix(core)
+
+Update dependencies and changelog
+
+- Updated @push.rocks/smartstream to ^3.0.44
+- Updated glob to ^10.4.2
+- Updated @types/node to ^20.14.8
+
+## 2024-06-23 - 11.0.21 - fix(dependencies)
+
+Update dependencies to latest versions
+
+- Updated @push.rocks/smartpromise to ^4.0.4
+- Updated @push.rocks/smartstream to ^3.0.44
+- Updated glob to ^10.4.2
+- Updated @types/node to ^20.14.8
+
+## 2024-06-07 - 11.0.20 - Changelog
+
+11.0.20
+
+## 2024-06-07 - 11.0.19 - fix(core): update
+
+11.0.19
+
+- fix(core): update
+
+## 2024-06-07 - 11.0.18 - fix(core): update
+
+11.0.18
+
+- fix(core): update
+
+## 2024-06-06 - 11.0.17 - fix(core): update
+
+11.0.17
+
+- fix(core): update
+
+## 2024-06-06 - 11.0.16 - fix(core): update
+
+11.0.16
+
+- fix(core): update
+
+## 2024-05-29 - 11.0.16 - update description
+
+11.0.16
+
+- update description
+
+## 2024-05-17 - 11.0.15 - fix(core): update
+
+11.0.15
+
+- fix(core): update
+
+## 2024-04-14 - 11.0.14 - update tsconfig
+
+11.0.14
+
+- update tsconfig
+
+## 2024-04-12 - 11.0.13 - fix(core): update
+
+11.0.13
+
+- fix(core): update
+
+## 2024-04-12 - 11.0.12 - fix(core): update
+
+11.0.12
+
+- fix(core): update
+
+## 2024-04-12 - 11.0.11 - fix(core): update
+
+11.0.11
+
+- fix(core): update
+
+## 2024-04-03 - 11.0.10 - fix(core): update
+
+11.0.10
+
+- fix(core): update
+
+## 2024-04-03 - 11.0.9 - fix(core): update
+
+11.0.9
+
+- fix(core): update
+
+## 2024-04-02 - 11.0.8 - fix(core): update
+
+11.0.8
+
+- fix(core): update
+
+## 2024-04-02 - 11.0.7 - fix(core): update
+
+11.0.7
+
+- fix(core): update
+
+## 2024-04-02 - 11.0.6 - fix(core): update
+
+11.0.6
+
+- fix(core): update
+
+## 2024-04-01 - 11.0.5 - update npmextra.json
+
+11.0.5
+
+- update npmextra.json: githost
+
+## 2024-04-01 - 11.0.4 - fix(core): update
+
+11.0.4
+
+- fix(core): update
+
+## 2023-11-24 - 11.0.3 - fix(core): update
+
+11.0.3
+
+- fix(core): update
+
+## 2023-11-07 - 11.0.2 - fix(core): update
+
+11.0.2
+
+- fix(core): update
+
+## 2023-11-07 - 11.0.1 - fix(core): update
+
+11.0.1
+
+- fix(core): update
+
+## 2023-11-06 - 11.0.0 - fix(core): update
+
+11.0.0
+
+- fix(core): update
+
+## 2023-11-06 - 10.0.40 - BREAKING CHANGE(core): update
+
+10.0.40
+
+- BREAKING CHANGE(core): update
+
+## 2023-11-04 - 10.0.39 - fix(core): update
+
+10.0.39
+
+- fix(core): update
+
+## 2023-11-04 - 10.0.38 - fix(core): update
+
+10.0.38
+
+- fix(core): update
+
+## 2023-11-04 - 10.0.37 - fix(core): update
+
+10.0.37
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.36 - fix(core): update
+
+10.0.36
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.35 - fix(core): update
+
+10.0.35
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.34 - fix(core): update
+
+10.0.34
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.33 - fix(core): update
+
+10.0.33
+
+- fix(core): update
+
+## 2023-10-12 - 10.0.32 - fix(core): update
+
+10.0.32
+
+- fix(core): update
+
+## 2023-09-22 - 10.0.31 - fix(core): update
+
+10.0.31
+
+- fix(core): update
+
+## 2023-08-31 - 10.0.30 - fix(core): update
+
+10.0.30
+
+- fix(core): update
+
+## 2023-08-23 - 10.0.29 - fix(core): update
+
+10.0.29
+
+- fix(core): update
+
+## 2023-07-12 - 10.0.28 - fix(core): update
+
+10.0.28
+
+- fix(core): update
+
+## 2023-07-10 - 10.0.27 - fix(core): update
+
+10.0.27
+
+- fix(core): update
+
+## 2023-07-10 - 10.0.26 - fix(core): update
+
+10.0.26
+
+- fix(core): update
+
+## 2023-07-08 - 10.0.25 - fix(core): update
+
+10.0.25
+
+- fix(core): update
+
+## 2023-06-25 - 10.0.24 to 10.0.14 - Series of Fixes
+
+10.0.24 to 10.0.14
+
+- Series of fixes in the core module
+
+## 2023-01-09 - 10.0.13 to 10.0.6 - Series of Fixes
+
+10.0.13 to 10.0.6
+
+- Series of fixes in the core module
+
+## 2022-09-05 - 10.0.5 to 10.0.3 - Series of Fixes
+
+10.0.5 to 10.0.3
+
+- Series of fixes in the core module
+
+## 2022-06-07 - 10.0.2 to 10.0.1 - Series of Fixes
+
+10.0.2 to 10.0.1
+
+- Series of fixes in the core module
+
+## 2022-06-07 - 9.0.7 - BREAKING CHANGE(core): switch to esm
+
+9.0.7
+
+- BREAKING CHANGE(core): switch to esm
+
+## 2022-03-11 - 9.0.6 to 9.0.2 - Series of Fixes
+
+9.0.6 to 9.0.2
+
+- Series of fixes in the core module
+
+## 2021-12-01 - 9.0.1 - fix(core): update
+
+9.0.1
+
+- fix(core): update
+
+## 2021-12-01 - 9.0.0 - fix(absolute pathing)
+
+9.0.0
+
+- add functions for easily getting absolute paths
+
+## 2021-11-30 - 8.0.11 - BREAKING CHANGE(relative pathing)
+
+8.0.11
+
+- improved relative pathing
+
+## 2020-08-10 - 8.0.10 to 7.0.12 - Series of Fixes and Updates
+
+8.0.10 to 7.0.12
+
+- Series of fixes in the core module
+- BREAKING CHANGE(Smartfile class): switch to a Buffer-only approach
+
+## 2019-02-17 - 7.0.0 - fix(core): update dependencies
+
+7.0.0
+
+- fix(core): update dependencies
+
+## 2019-01-27 - 6.0.12 - BREAKING CHANGE(smartfile.fs.fileExists)
+
+6.0.12
+
+- now returns a Promise<boolean>
+
+## 2018-08-19 - 6.0.11 to 6.0.6 - Series of Fixes
+
+6.0.11 to 6.0.6
+
+- Series of fixes in core and dependencies
+
+## 2018-07-03 - 6.0.5 to 5.0.0 - Series of Fixes
+
+6.0.5 to 5.0.0
+
+- Series of fixes in core and dependencies
+
+## 2018-02-16 - 4.2.28 - BREAKING CHANGE(scope)
+
+4.2.28
+
+- switch to pushrocks scope

npmextra.json

@@ -10,33 +10,36 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartfile",
-      "description": "provides a robust suite of tools for managing files in Node.js using TypeScript.",
+      "description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
       "npmPackagename": "@push.rocks/smartfile",
       "license": "MIT",
       "keywords": [
-        "files management",
+        "file management",
         "TypeScript",
         "Node.js",
-        "read files",
-        "write files",
-        "copy files",
+        "file operations",
+        "file manipulation",
         "file streaming",
-        "directories manipulation",
-        "virtual file system",
+        "virtual directory",
         "filesystem utilities",
-        "ESM syntax",
-        "memory-efficient streaming"
+        "memory-efficient file handling",
+        "custom file operations",
+        "write files",
+        "read files",
+        "copy files",
+        "delete files",
+        "list directories",
+        "handle large files",
+        "virtual filesystems",
+        "buffer operations"
       ]
     }
   },
   "tsdoc": {
-    "classes": [
-      "SmartFile",
-      "StreamFile"
-    ],
+    "classes": ["SmartFile", "StreamFile"],
     "descriptions": [
       "the purpose of the StreamFile class is to provide a hybrid interface between streaming files and simple handling when writing and reading those files multiple times."
     ],
     "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"
   }
-}
+}

package.json

@@ -1,64 +1,68 @@
 {
   "name": "@push.rocks/smartfile",
   "private": false,
-  "version": "11.0.14",
-  "description": "provides a robust suite of tools for managing files in Node.js using TypeScript.",
+  "version": "11.2.6",
+  "description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
   "scripts": {
-    "test": "(tstest test/)",
+    "test": "(tstest test/ --verbose --logfile --timeout 120)",
     "build": "(tsbuild --web --allowimplicitany)",
     "buildDocs": "tsdoc"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://gitlab.com/push.rocks/smartfile.git"
+    "url": "https://code.foss.global/push.rocks/smartfile.git"
   },
   "keywords": [
-    "files management",
+    "file management",
     "TypeScript",
     "Node.js",
-    "read files",
-    "write files",
-    "copy files",
+    "file operations",
+    "file manipulation",
     "file streaming",
-    "directories manipulation",
-    "virtual file system",
+    "virtual directory",
     "filesystem utilities",
-    "ESM syntax",
-    "memory-efficient streaming"
+    "memory-efficient file handling",
+    "custom file operations",
+    "write files",
+    "read files",
+    "copy files",
+    "delete files",
+    "list directories",
+    "handle large files",
+    "virtual filesystems",
+    "buffer operations"
   ],
   "author": "Lossless GmbH <hello@lossless.com> (https://lossless.com)",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/push.rocks/smartfile/issues"
+    "url": "https://code.foss.global/push.rocks/smartfile/issues"
   },
-  "homepage": "https://gitlab.com/push.rocks/smartfile#readme",
+  "homepage": "https://code.foss.global/push.rocks/smartfile#readme",
   "dependencies": {
-    "@push.rocks/lik": "^6.0.14",
+    "@push.rocks/lik": "^6.2.2",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartfile-interfaces": "^1.0.7",
-    "@push.rocks/smarthash": "^3.0.4",
-    "@push.rocks/smartjson": "^5.0.16",
-    "@push.rocks/smartmime": "^1.0.5",
-    "@push.rocks/smartpath": "^5.0.13",
-    "@push.rocks/smartpromise": "^4.0.2",
-    "@push.rocks/smartrequest": "^2.0.21",
-    "@push.rocks/smartstream": "^3.0.34",
+    "@push.rocks/smarthash": "^3.2.3",
+    "@push.rocks/smartjson": "^5.0.20",
+    "@push.rocks/smartmime": "^2.0.4",
+    "@push.rocks/smartpath": "^6.0.0",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartrequest": "^4.2.1",
+    "@push.rocks/smartstream": "^3.2.5",
     "@types/fs-extra": "^11.0.4",
-    "@types/glob": "^8.1.0",
     "@types/js-yaml": "^4.0.9",
-    "fs-extra": "^11.2.0",
-    "glob": "^10.3.12",
+    "fs-extra": "^11.3.1",
+    "glob": "^11.0.3",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.72",
-    "@git.zone/tsrun": "^1.2.46",
-    "@git.zone/tstest": "^1.0.88",
-    "@push.rocks/tapbundle": "^5.0.22",
-    "@types/node": "^20.12.7"
+    "@git.zone/tsbuild": "^2.6.4",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^2.3.4",
+    "@types/node": "^22.15.21"
   },
   "files": [
     "ts/**/*",
@@ -74,5 +78,9 @@
   ],
   "browserslist": [
     "last 1 chrome versions"
-  ]
+  ],
+  "packageManager": "pnpm@10.10.0+sha512.d615db246fe70f25dcfea6d8d73dee782ce23e2245e3c4f6f888249fb568149318637dca73c2c5c8ef2a4ca0d5657fb9567188bfab47f566d1ee6ce987815c39",
+  "pnpm": {
+    "overrides": {}
+  }
 }

readme.hints.md

@@ -0,0 +1,33 @@
+# SmartFile Implementation Hints
+
+## listFileTree Function Enhancement (ts/fs.ts:367-415)
+
+### Issue Fixed
+
+The `listFileTree` function previously had inconsistent behavior with `**/*.extension` patterns across different systems and glob implementations. Some implementations would miss root-level files when using patterns like `**/*.ts`.
+
+### Solution Implemented
+
+Modified the function to explicitly handle `**/` patterns by:
+
+1. Detecting when a pattern starts with `**/`
+2. Extracting the file pattern after `**/` (e.g., `*.ts` from `**/*.ts`)
+3. Running both the original pattern and the extracted root pattern
+4. Using a Set to deduplicate results and ensure consistent ordering
+
+### Key Benefits
+
+- Guarantees consistent behavior across all systems
+- Ensures both root-level and nested files are found with `**/*` patterns
+- Maintains backward compatibility
+- No performance degradation due to efficient deduplication
+
+### Test Coverage
+
+Added comprehensive tests to verify:
+
+- Both root and nested files are found with `**/*.ts`
+- No duplicate entries in results
+- Edge cases with various file extensions work correctly
+
+This fix ensures tools like `tsbuild check **/*.ts` work reliably across all systems.

readme.md

@@ -1,263 +1,314 @@
-# @push.rocks/smartfile
+# @push.rocks/smartfile 📁
 
-> Provides a robust suite of tools for managing files in Node.js using TypeScript.
+> **A powerful, TypeScript-based file management library for Node.js**
 
-## Install
+## 🚀 What is smartfile?
 
-To integrate `@push.rocks/smartfile` into your project, run:
+`@push.rocks/smartfile` is your go-to solution for file operations in Node.js. It offers a clean, promise-based API for handling files, directories, streams, and even virtual filesystems - all while maintaining maximum performance and reliability.
+
+Think of it as `fs` on steroids, with TypeScript superpowers! 💪
+
+## 💾 Installation
 
 ```bash
 npm install @push.rocks/smartfile
 ```
 
-## Usage
+## ✨ Features
 
-`@push.rocks/smartfile` offers a comprehensive set of utilities for handling files in Node.js projects using modern TypeScript and ESM syntax. It simplifies various file operations such as reading, writing, copying, and streaming files, as well as working with directories and virtual file systems.
+- 🔥 **Streaming Support** - Handle massive files with ease using `StreamFile`
+- 📦 **Virtual Directories** - Work with in-memory file structures
+- 🌐 **URL Support** - Directly work with files from URLs
+- 🎯 **TypeScript First** - Full type safety and IntelliSense support
+- ⚡ **Promise-based API** - Modern async/await patterns throughout
+- 🛠️ **Comprehensive Toolset** - From basic CRUD to advanced operations
 
-### Key Features and Classes
-
-- **`SmartFile`**: Facilitates reading from and writing to individual files, managing metadata.
-- **`StreamFile`**: Optimizes memory usage by enabling efficient file streaming.
-- **`VirtualDirectory`**: Allows manipulation of a group of files or directories as a virtual file system.
-
-### Getting Started with ESM and TypeScript
-
-First, ensure your project supports ESM syntax and TypeScript. Then, begin by importing the desired features from `@push.rocks/smartfile`:
+## 📚 Quick Start
 
 ```typescript
-import { SmartFile, StreamFile, VirtualDirectory, memory, fs as smartFs } from '@push.rocks/smartfile';
+import * as smartfile from '@push.rocks/smartfile';
+
+// Read a file
+const content = await smartfile.fs.toStringSync('./my-file.txt');
+
+// Write a file
+await smartfile.memory.toFs('Hello World!', './output.txt');
+
+// Work with JSON
+const data = await smartfile.fs.toObjectSync('./data.json');
 ```
 
-### Reading and Writing Files
+## 🎨 Core Components
 
-#### Reading Files
+### SmartFile Class
 
-Reading a JSON file:
+The `SmartFile` class represents a single file with powerful manipulation capabilities:
 
 ```typescript
-const myJsonFile: SmartFile = await SmartFile.fromFilePath('./data.json');
-const jsonData = JSON.parse(myJsonFile.contents.toString());
-console.log(jsonData);
+import { SmartFile } from '@push.rocks/smartfile';
+
+// Create from file path
+const fileFromPath = await SmartFile.fromFilePath('./data.json');
+
+// Create from URL
+const fileFromUrl = await SmartFile.fromUrl('https://example.com/config.json');
+
+// Create from text
+const fileFromText = await SmartFile.fromString(
+  './my-file.txt',
+  'This is my content',
+  'utf8'
+);
+
+// Create from Buffer
+const fileFromBuffer = await SmartFile.fromBuffer(
+  './binary.dat',
+  Buffer.from([0x00, 0x01, 0x02])
+);
+
+// Edit content
+await fileFromPath.editContentAsString(async (content) => {
+  return content.replace(/old/g, 'new');
+});
+
+// Write to disk
+await fileFromPath.write();
+
+// Get content
+const contentString = fileFromPath.parseContentAsString();
+const contentBuffer = fileFromPath.parseContentAsBuffer();
 ```
 
-#### Writing Files
+### StreamFile Class 🌊
 
-Writing content to a file:
+Perfect for handling large files without memory overhead:
 
 ```typescript
-const filePath: string = './output.txt';
-const content: string = 'Hello, SmartFile!';
-await memory.toFs(content, filePath);
-console.log('File saved successfully.');
+import { StreamFile } from '@push.rocks/smartfile';
+
+// Create from path
+const streamFile = await StreamFile.fromPath('./bigfile.zip');
+
+// Create from URL
+const urlStream = await StreamFile.fromUrl('https://example.com/large.mp4');
+
+// Create from buffer
+const bufferStream = StreamFile.fromBuffer(
+  Buffer.from('streaming content'),
+  'stream.txt'
+);
+
+// Write to disk
+await streamFile.writeToDisk('./output/bigfile.zip');
+
+// Get as buffer (careful with large files!)
+const buffer = await streamFile.getContentAsBuffer();
+
+// Get as stream
+const readStream = await streamFile.createReadStream();
 ```
 
-### Streaming Large Files
+### VirtualDirectory Class 📂
 
-For large files, `StreamFile` provides a memory-efficient streaming solution:
+Manage collections of files as virtual filesystems:
 
 ```typescript
-import { createReadStream } from 'fs';
-const sourceStream = createReadStream('./large-video.mp4');
-const myStreamFile = await StreamFile.fromStream(sourceStream, 'large-video.mp4');
-await myStreamFile.writeToDir('./storage');
-console.log('Large file streamed to disk successfully.');
+import { VirtualDirectory } from '@push.rocks/smartfile';
+
+// Create from filesystem
+const vDir = await VirtualDirectory.fromFsDirPath('./src');
+
+// Create from file array
+const vDirFromFiles = await VirtualDirectory.fromFileArray([
+  await SmartFile.fromFilePath('./file1.txt'),
+  await SmartFile.fromFilePath('./file2.txt')
+]);
+
+// Add files
+vDir.addSmartfiles([
+  await SmartFile.fromString('./virtual/new.txt', 'content')
+]);
+
+// List files
+const files = vDir.listFiles();
+const directories = vDir.listDirectories();
+
+// Get file
+const file = vDir.getFileByPath('./some/path.txt');
+
+// Save to disk
+await vDir.saveToDisk('./output');
+
+// Load from disk
+await vDir.loadFromDisk('./source');
 ```
 
-### Working with Virtual Directories
+## 🛠️ File Operations
 
-`VirtualDirectory` abstracts a collection of files allowing operations to be performed as if they were on disk:
+### Basic Operations
 
 ```typescript
-const virtualDir = new VirtualDirectory();
-virtualDir.addSmartfiles([smartFile1, smartFile2]); // Assuming these are SmartFile instances
-await virtualDir.saveToDisk('./virtual-output');
-console.log('Virtual directory saved to disk.');
+// Check existence
+const exists = await smartfile.fs.fileExists('./file.txt');
+const existsSync = smartfile.fs.fileExistsSync('./file.txt');
+
+// Read operations
+const content = await smartfile.fs.toStringSync('./file.txt');
+const buffer = await smartfile.fs.toBuffer('./file.txt');
+const object = await smartfile.fs.toObjectSync('./data.json');
+
+// Write operations
+await smartfile.memory.toFs('content', './output.txt');
+smartfile.memory.toFsSync('content', './output-sync.txt');
+
+// Copy operations
+await smartfile.fs.copy('./source.txt', './dest.txt');
+await smartfile.fs.copy('./src-dir', './dest-dir');
+
+// Delete operations
+await smartfile.fs.remove('./file.txt');
+await smartfile.fs.removeSync('./file-sync.txt');
+await smartfile.fs.removeMany(['./file1.txt', './file2.txt']);
+
+// Ensure operations (create if not exists)
+await smartfile.fs.ensureDir('./my/deep/directory');
+await smartfile.fs.ensureFile('./my/file.txt');
+await smartfile.fs.ensureEmptyDir('./empty-dir');
 ```
 
-### Advanced File Operations
+### Directory Operations
 
-`@push.rocks/smartfile` simplifies complex file operations, including:
-- Copying directories and files
-- Removing files or directories
-- Listing files and directories with filters
-- Reading file content directly into JavaScript objects
+```typescript
+// List contents
+const files = await smartfile.fs.listFiles('./directory');
+const folders = await smartfile.fs.listFolders('./directory');
+const items = await smartfile.fs.listAllItems('./directory');
 
-### Web File Handling
+// Get file tree
+const tree = await smartfile.fs.listFileTree('./src', '**/*.ts');
 
-Handling files from HTTP requests:
-`@push.rocks/smartfile` offers utilities to work with files from web sources, making it simpler to manage downloads and uploads.
+// Directory checks
+const isDir = await smartfile.fs.isDirectory('./path');
+const isFile = await smartfile.fs.isFile('./path');
+```
 
-### Comprehensive File Management
+### Advanced Features
 
-Whether you're dealing with local files, directories, or files over the internet, `@push.rocks/smartfile` provides a comprehensive set of tools to streamline your workflow and reduce the complexity of file management in your Node.js projects.
+```typescript
+// Wait for file to be ready
+await smartfile.fs.waitForFileToBeReady('./file.txt');
 
-## API Reference
+// Stream operations
+const readStream = smartfile.fsStream.createReadStream('./input.txt');
+const writeStream = smartfile.fsStream.createWriteStream('./output.txt');
 
-### `SmartFile` Class
+// File type detection
+const fileType = smartfile.interpreter.filetype('./document.pdf');
+// Returns: 'pdf'
 
-#### Static Methods
+// Smart read stream (with custom processing)
+const smartStream = new smartfile.fsStream.SmartReadStream('./data.txt');
+smartStream.on('data', (chunk) => {
+  // Process chunk
+  console.log(chunk.toString());
+});
+```
 
-- `SmartFile.fromFilePath(filePath: string, baseArg?: string): Promise<SmartFile>`
-  - Creates a `SmartFile` instance from a file path.
-- `SmartFile.fromBuffer(filePath: string, contentBufferArg: Buffer, baseArg?: string): Promise<SmartFile>`
-  - Creates a `SmartFile` instance from a `Buffer`.
-- `SmartFile.fromString(filePath: string, contentStringArg: string, encodingArg: 'utf8' | 'binary', baseArg?: string): Promise<SmartFile>`
-  - Creates a `SmartFile` instance from a string.
-- `SmartFile.fromFoldedJson(foldedJsonArg: string): Promise<SmartFile>`
-  - Creates a `SmartFile` instance from a folded JSON string.
-- `SmartFile.fromStream(stream: Readable, filePath: string, baseArg?: string): Promise<SmartFile>`
-  - Creates a `SmartFile` instance from a `Readable` stream.
-- `SmartFile.fromUrl(urlArg: string): Promise<SmartFile>`
-  - Creates a `SmartFile` instance from a URL.
+## 🔄 Working with Multiple Files
 
-#### Instance Properties
+```typescript
+// Process multiple SmartFiles
+const files = await smartfile.fs.fileTreeToObject(
+  './src',
+  '**/*.{ts,js}'
+);
 
-- `path: string`
-  - The relative path of the file.
-- `parsedPath: path.ParsedPath`
-  - A parsed path object.
-- `absolutePath: string`
-  - The absolute path of the file.
-- `absoluteParsedPath: path.ParsedPath`
-  - A parsed absolute path object.
-- `contentBuffer: Buffer`
-  - The content of the file as a `Buffer`.
-- `base: string`
-  - The current working directory of the file.
-- `sync: boolean`
-  - Indicates whether the file is synced with the disk.
+// Write array to disk
+const smartfiles = [
+  await SmartFile.fromString('file1.txt', 'content1'),
+  await SmartFile.fromString('file2.txt', 'content2')
+];
+await smartfile.memory.smartfileArrayToFs(smartfiles, './output');
+```
 
-#### Instance Methods
+## 🎯 Real-World Examples
 
-- `setContentsFromString(contentString: string, encodingArg?: 'utf8' | 'binary'): void`
-  - Sets the contents of the file from a string.
-- `write(): Promise<void>`
-  - Writes the file to disk at its original location.
-- `writeToDiskAtPath(filePathArg: string): Promise<void>`
-  - Writes the file to the specified path on disk.
-- `writeToDir(dirPathArg: string): Promise<string>`
-  - Writes the file to a directory combined with the relative path portion.
-- `read(): Promise<void>`
-  - Reads the file from disk.
-- `delete(): Promise<void>`
-  - Deletes the file from disk at its original location.
-- `getHash(typeArg?: 'path' | 'content' | 'all'): Promise<string>`
-  - Returns a hash of the file based on the specified type.
-- `updateFileName(fileNameArg: string): void`
-  - Updates the file name of the `SmartFile` instance.
-- `editContentAsString(editFuncArg: (fileStringArg: string) => Promise<string>): Promise<void>`
-  - Edits the content of the file as a string using the provided edit function.
-- `getStream(): Readable`
-  - Returns a `Readable` stream from the file's content buffer.
+### Website Bundler
+```typescript
+// Bundle website assets
+const website = await VirtualDirectory.fromFsDirPath('./website');
+const bundle = await website.smartfileArray;
 
-### `StreamFile` Class
+// Process all CSS files
+for (const file of bundle.filter(f => f.path.endsWith('.css'))) {
+  await file.editContentAsString(async (css) => {
+    // Minify CSS here
+    return css.replace(/\s+/g, ' ');
+  });
+}
 
-#### Static Methods
+// Save processed bundle
+await website.saveToDisk('./dist');
+```
 
-- `StreamFile.fromPath(filePath: string): Promise<StreamFile>`
-  - Creates a `StreamFile` instance from a file path.
-- `StreamFile.fromUrl(url: string): Promise<StreamFile>`
-  - Creates a `StreamFile` instance from a URL.
-- `StreamFile.fromBuffer(buffer: Buffer, relativeFilePath?: string): StreamFile`
-  - Creates a `StreamFile` instance from a `Buffer`.
-- `StreamFile.fromStream(stream: Readable, relativeFilePath?: string, multiUse?: boolean): StreamFile`
-  - Creates a `StreamFile` instance from a `Readable` stream.
+### File Watcher & Processor
+```typescript
+// Watch for new files and process them
+import { SmartFile, StreamFile } from '@push.rocks/smartfile';
 
-#### Instance Properties
+async function processLargeFile(filePath: string) {
+  const streamFile = await StreamFile.fromPath(filePath);
+  
+  // Stream to processed location
+  await streamFile.writeToDisk(`./processed/${path.basename(filePath)}`);
+  
+  // Clean up original
+  await smartfile.fs.remove(filePath);
+}
+```
 
-- `relativeFilePath?: string`
-  - The relative file path of the `StreamFile`.
-- `multiUse: boolean`
-  - Indicates whether the `StreamFile` can be used multiple times.
-- `used: boolean`
-  - Indicates whether the `StreamFile` has been used.
+### Configuration Manager
+```typescript
+// Load and merge config files
+const defaultConfig = await smartfile.fs.toObjectSync('./config.default.json');
+const userConfig = await smartfile.fs.toObjectSync('./config.user.json');
 
-#### Instance Methods
+const merged = { ...defaultConfig, ...userConfig };
 
-- `createReadStream(): Promise<Readable>`
-  - Creates a new `Readable` stream from the source.
-- `writeToDisk(filePathArg: string): Promise<void>`
-  - Writes the stream to the disk at the specified path.
-- `writeToDir(dirPathArg: string): Promise<void>`
-  - Writes the stream to a directory combined with the relative path portion.
-- `getContentAsBuffer(): Promise<Buffer>`
-  - Returns the content of the `StreamFile` as a `Buffer`.
-- `getContentAsString(formatArg?: 'utf8' | 'binary'): Promise<string>`
-  - Returns the content of the `StreamFile` as a string.
+await smartfile.memory.toFs(
+  JSON.stringify(merged, null, 2),
+  './config.final.json'
+);
+```
 
-### `VirtualDirectory` Class
+## 🌟 API Reference
 
-#### Static Methods
+### Core Modules
 
-- `VirtualDirectory.fromFsDirPath(pathArg: string): Promise<VirtualDirectory>`
-  - Creates a `VirtualDirectory` instance from a file system directory path.
-- `VirtualDirectory.fromVirtualDirTransferableObject(virtualDirTransferableObjectArg: VirtualDirTransferableObject): Promise<VirtualDirectory>`
-  - Creates a `VirtualDirectory` instance from a `VirtualDirTransferableObject`.
+- `fs` - File system operations
+- `fsStream` - Streaming operations
+- `memory` - Memory/buffer operations
+- `interpreter` - File type detection
 
-#### Instance Properties
+### Main Classes
 
-- `smartfileArray: SmartFile[]`
-  - An array of `SmartFile` instances in the `VirtualDirectory`.
+- `SmartFile` - Single file representation
+- `StreamFile` - Streaming file operations
+- `VirtualDirectory` - Virtual filesystem management
 
-#### Instance Methods
+## 🏗️ TypeScript Support
 
-- `addSmartfiles(smartfileArrayArg: SmartFile[]): void`
-  - Adds an array of `SmartFile` instances to the `VirtualDirectory`.
-- `getFileByPath(pathArg: string): Promise<SmartFile | undefined>`
-  - Retrieves a `SmartFile` instance from the `VirtualDirectory` by its path.
-- `toVirtualDirTransferableObject(): Promise<VirtualDirTransferableObject>`
-  - Converts the `VirtualDirectory` to a `VirtualDirTransferableObject`.
-- `saveToDisk(dirArg: string): Promise<void>`
-  - Saves the `VirtualDirectory` to the disk at the specified directory.
-- `shiftToSubdirectory(subDir: string): Promise<VirtualDirectory>`
-  - Shifts the `VirtualDirectory` to a subdirectory.
-- `addVirtualDirectory(virtualDir: VirtualDirectory, newRoot: string): Promise<void>`
-  - Adds another `VirtualDirectory` to the current `VirtualDirectory` with a new root path.
+Full TypeScript support with comprehensive type definitions:
 
-### `fs` Module
+```typescript
+import type { SmartFile, StreamFile, VirtualDirectory } from '@push.rocks/smartfile';
 
-The `fs` module provides various file system utility functions. Some notable functions include:
-
-- `fileExistsSync(filePath: string): boolean`
-  - Checks if a file exists synchronously.
-- `fileExists(filePath: string): Promise<boolean>`
-  - Checks if a file exists asynchronously.
-- `listFoldersSync(pathArg: string, regexFilter?: RegExp): string[]`
-  - Lists folders in a directory synchronously.
-- `listFolders(pathArg: string, regexFilter?: RegExp): Promise<string[]>`
-  - Lists folders in a directory asynchronously.
-- `listFilesSync(pathArg: string, regexFilter?: RegExp): string[]`
-  - Lists files in a directory synchronously.
-- `listFiles(pathArg: string, regexFilter?: RegExp): Promise<string[]>`
-  - Lists files in a directory asynchronously.
-- `listFileTree(dirPathArg: string, miniMatchFilter: string, absolutePathsBool?: boolean): Promise<string[]>`
-  - Lists a file tree using a minimatch filter.
-- `waitForFileToBeReady(filePathArg: string): Promise<void>`
-  - Waits for a file to be ready (exists and is not empty).
-- `toFs(filePathArg: string, fileContentArg: string | Buffer | SmartFile | StreamFile, optionsArg?: { respectRelative?: boolean }): Promise<void>`
-  - Writes a string, `Buffer`, `SmartFile`, or `StreamFile` to the file system.
-
-### `memory` Module
-
-The `memory` module provides utility functions for working with files in memory. Some notable functions include:
-
-- `toObject(fileStringArg: string, fileTypeArg: string): any`
-  - Converts a file string to an object based on the file type.
-- `toFs(fileContentArg: string | Buffer | SmartFile | StreamFile, filePathArg: string, optionsArg?: IToFsOptions): Promise<void>`
-  - Writes a string, `Buffer`, `SmartFile`, or `StreamFile` to the file system.
-- `toFsSync(fileArg: string, filePathArg: string): void`
-  - Writes a string to the file system synchronously.
-- `smartfileArrayToFs(smartfileArrayArg: SmartFile[], dirArg: string): Promise<void>`
-  - Writes an array of `SmartFile` instances to the file system.
-
-### `interpreter` Module
-
-The `interpreter` module provides utility functions for interpreting file types and contents. Some notable functions include:
-
-- `filetype(pathArg: string): string`
-  - Determines the file type based on the file path.
-- `objectFile(fileStringArg: string, fileTypeArg: any): any`
-  - Converts a file string to an object based on the file type.
+// All methods are fully typed
+const processFile = async (file: SmartFile): Promise<void> => {
+  const content = file.parseContentAsString();
+  // TypeScript knows content is string
+};
+```
 
 ## License and Legal Information
 

test/test.streamfile.ts

@@ -1,5 +1,5 @@
 import * as path from 'path';
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as smartfile from '../ts/index.js'; // adjust the import path as needed
 
 // Test assets path
@@ -9,55 +9,85 @@ const testAssetsPath = './test/testassets/';
 // StreamFile tests
 // ---------------------------
 
-tap.test('StreamFile.fromPath should create a StreamFile from a file path', async () => {
-  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
-  expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
-  const contentBuffer = await streamFile.getContentAsBuffer();
-  expect(contentBuffer).toBeInstanceOf(Buffer);
-});
+tap.test(
+  'StreamFile.fromPath should create a StreamFile from a file path',
+  async () => {
+    const streamFile = await smartfile.StreamFile.fromPath(
+      path.join(testAssetsPath, 'mytest.json'),
+    );
+    expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
+    const contentBuffer = await streamFile.getContentAsBuffer();
+    expect(contentBuffer).toBeInstanceOf(Buffer);
+  },
+);
 
-tap.test('StreamFile.fromUrl should create a StreamFile from a URL', async () => {
-  const streamFile = await smartfile.StreamFile.fromUrl('http://example.com/somefile.json');
-  expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
-});
+tap.test(
+  'StreamFile.fromUrl should create a StreamFile from a URL',
+  async () => {
+    const streamFile = await smartfile.StreamFile.fromUrl(
+      'http://example.com/somefile.json',
+    );
+    expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
+  },
+);
 
-tap.test('StreamFile.fromBuffer should create a StreamFile from a Buffer', async () => {
-  const buffer = Buffer.from('Some content');
-  const streamFile = smartfile.StreamFile.fromBuffer(buffer, 'bufferfile.txt');
-  expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
-});
+tap.test(
+  'StreamFile.fromBuffer should create a StreamFile from a Buffer',
+  async () => {
+    const buffer = Buffer.from('Some content');
+    const streamFile = smartfile.StreamFile.fromBuffer(
+      buffer,
+      'bufferfile.txt',
+    );
+    expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
+  },
+);
 
 tap.test('StreamFile should write the stream to disk', async () => {
-  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
-  await streamFile.writeToDisk(path.join(testAssetsPath, 'temp', 'mytest.json'));
+  const streamFile = await smartfile.StreamFile.fromPath(
+    path.join(testAssetsPath, 'mytest.json'),
+  );
+  await streamFile.writeToDisk(
+    path.join(testAssetsPath, 'temp', 'mytest.json'),
+  );
   // Verify the file was written
   expect(
     // We'll use the fileExists method from your smartfile library
     // Replace with the actual method you use to check file existence
-    await smartfile.fs.fileExists(path.join(testAssetsPath, 'temp', 'mytest.json'))
+    await smartfile.fs.fileExists(
+      path.join(testAssetsPath, 'temp', 'mytest.json'),
+    ),
   ).toBeTrue();
 });
 
 tap.test('StreamFile should write to a directory', async () => {
-  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
+  const streamFile = await smartfile.StreamFile.fromPath(
+    path.join(testAssetsPath, 'mytest.json'),
+  );
   await streamFile.writeToDir(path.join(testAssetsPath, 'temp'));
   // Verify the file was written
   expect(
-    await smartfile.fs.fileExists(path.join(testAssetsPath, 'temp', 'mytest.json'))
+    await smartfile.fs.fileExists(
+      path.join(testAssetsPath, 'temp', 'mytest.json'),
+    ),
   ).toBeTrue();
 });
 
 tap.test('StreamFile should return content as a buffer', async () => {
-  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
+  const streamFile = await smartfile.StreamFile.fromPath(
+    path.join(testAssetsPath, 'mytest.json'),
+  );
   const contentBuffer = await streamFile.getContentAsBuffer();
   expect(contentBuffer).toBeInstanceOf(Buffer);
   // Further checks on the content can be added here if necessary
 });
 
 tap.test('StreamFile should return content as a string', async () => {
-  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
+  const streamFile = await smartfile.StreamFile.fromPath(
+    path.join(testAssetsPath, 'mytest.json'),
+  );
   const contentString = await streamFile.getContentAsString();
-  expect(typeof contentString).toBeTypeofString();
+  expect(contentString).toBeTypeofString();
   // Verify the content matches what's expected
   // This assumes the file contains a JSON object with a key 'key1' with value 'this works'
   expect(JSON.parse(contentString).key1).toEqual('this works');

test/test.ts

@@ -1,85 +1,168 @@
 import * as smartfile from '../ts/index.js';
 import * as path from 'path';
 
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 
 // ---------------------------
 // smartfile.fs
 // ---------------------------
 
-tap.test('.fs.fileExistsSync -> should return an accurate boolean', async () => {
-  // tslint:disable-next-line: no-unused-expression
-  expect(smartfile.fs.fileExistsSync('./test/testassets/mytest.json')).toBeTrue();
-  // tslint:disable-next-line: no-unused-expression
-  expect(smartfile.fs.fileExistsSync('./test/testassets/notthere.json')).toBeFalse();
-});
+tap.test(
+  '.fs.fileExistsSync -> should return an accurate boolean',
+  async () => {
+    // tslint:disable-next-line: no-unused-expression
+    expect(
+      smartfile.fs.fileExistsSync('./test/testassets/mytest.json'),
+    ).toBeTrue();
+    // tslint:disable-next-line: no-unused-expression
+    expect(
+      smartfile.fs.fileExistsSync('./test/testassets/notthere.json'),
+    ).toBeFalse();
+  },
+);
 
 tap.test('.fs.fileExists -> should resolve or reject a promise', async () => {
-  expect(smartfile.fs.fileExists('./test/testassets/mytest.json')).toBeInstanceOf(Promise);
-  await smartfile.fs.fileExists('./test/testassets/mytest.json');
-  await smartfile.fs.fileExists('./test/testassets/notthere.json').catch((err) => {
-    return expect(err.message).toEqual(
-      "ENOENT: no such file or directory, access './test/testassets/notthere.json'"
+  await expect(
+    smartfile.fs.fileExists('./test/testassets/mytest.json'),
+  ).resolves.toBeTrue();
+  await expect(
+    smartfile.fs.fileExists('./test/testassets/notthere.json'),
+  ).resolves.toBeFalse();
+});
+
+tap.test(
+  '.fs.listFoldersSync() -> should get the file type from a string',
+  async () => {
+    expect(smartfile.fs.listFoldersSync('./test/testassets/')).toContain(
+      'testfolder',
     );
-  });
-});
+    expect(smartfile.fs.listFoldersSync('./test/testassets/')).not.toContain(
+      'notExistentFolder',
+    );
+  },
+);
 
-tap.test('.fs.listFoldersSync() -> should get the file type from a string', async () => {
-  expect(smartfile.fs.listFoldersSync('./test/testassets/')).toContain('testfolder');
-  expect(smartfile.fs.listFoldersSync('./test/testassets/')).not.toContain('notExistentFolder');
-});
+tap.test(
+  '.fs.listFolders() -> should get the file type from a string',
+  async () => {
+    const folderArrayArg = await smartfile.fs.listFolders('./test/testassets/');
+    expect(folderArrayArg).toContain('testfolder');
+    expect(folderArrayArg).not.toContain('notExistentFolder');
+  },
+);
 
-tap.test('.fs.listFolders() -> should get the file type from a string', async () => {
-  const folderArrayArg = await smartfile.fs.listFolders('./test/testassets/');
-  expect(folderArrayArg).toContain('testfolder');
-  expect(folderArrayArg).not.toContain('notExistentFolder');
-});
+tap.test(
+  '.fs.listFilesSync() -> should get the file type from a string',
+  async () => {
+    expect(smartfile.fs.listFilesSync('./test/testassets/')).toContain(
+      'mytest.json',
+    );
+    expect(smartfile.fs.listFilesSync('./test/testassets/')).not.toContain(
+      'notExistentFile',
+    );
+    expect(
+      smartfile.fs.listFilesSync('./test/testassets/', /mytest\.json/),
+    ).toContain('mytest.json');
+    expect(
+      smartfile.fs.listFilesSync('./test/testassets/', /mytests.json/),
+    ).not.toContain('mytest.json');
+  },
+);
 
-tap.test('.fs.listFilesSync() -> should get the file type from a string', async () => {
-  expect(smartfile.fs.listFilesSync('./test/testassets/')).toContain('mytest.json');
-  expect(smartfile.fs.listFilesSync('./test/testassets/')).not.toContain('notExistentFile');
-  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytest\.json/)).toContain('mytest.json');
-  expect(smartfile.fs.listFilesSync('./test/testassets/', /mytests.json/)).not.toContain(
-    'mytest.json'
-  );
-});
-
-tap.test('.fs.listFiles() -> should get the file type from a string', async () => {
-  const folderArrayArg = await smartfile.fs.listFiles('./test/testassets/');
-  expect(folderArrayArg).toContain('mytest.json');
-  expect(folderArrayArg).not.toContain('notExistentFile');
-});
+tap.test(
+  '.fs.listFiles() -> should get the file type from a string',
+  async () => {
+    const folderArrayArg = await smartfile.fs.listFiles('./test/testassets/');
+    expect(folderArrayArg).toContain('mytest.json');
+    expect(folderArrayArg).not.toContain('notExistentFile');
+  },
+);
 
 tap.test('.fs.listFileTree() -> should get a file tree', async () => {
   const folderArrayArg = await smartfile.fs.listFileTree(
     path.resolve('./test/testassets/'),
-    '**/*.txt'
+    '**/*.txt',
   );
   expect(folderArrayArg).toContain('testfolder/testfile1.txt');
   expect(folderArrayArg).not.toContain('mytest.json');
 });
 
-tap.test('.fs.fileTreeToObject -> should read a file tree into an Object', async () => {
-  const fileArrayArg = await smartfile.fs.fileTreeToObject(
-    path.resolve('./test/testassets/'),
-    '**/*.txt'
-  );
-  expect(fileArrayArg[0]).toBeInstanceOf(smartfile.SmartFile);
-  expect(fileArrayArg[0].contents.toString()).toEqual(fileArrayArg[0].contentBuffer.toString());
-});
+tap.test(
+  '.fs.listFileTree() -> should find both root and nested .ts files with **/*.ts pattern',
+  async () => {
+    const tsFiles = await smartfile.fs.listFileTree(process.cwd(), '**/*.ts');
+    // Should find both root-level and nested TypeScript files
+    expect(tsFiles).toContain('ts/index.ts');
+    expect(tsFiles).toContain('ts/classes.smartfile.ts');
+    expect(tsFiles).toContain('test/test.ts');
+    // Should find files in multiple levels of nesting
+    expect(tsFiles.filter((f) => f.endsWith('.ts')).length).toBeGreaterThan(5);
+    // Verify it finds files at all levels (root 'ts/' and nested 'test/')
+    const hasRootLevelTs = tsFiles.some(
+      (f) => f.startsWith('ts/') && f.endsWith('.ts'),
+    );
+    const hasNestedTs = tsFiles.some(
+      (f) => f.startsWith('test/') && f.endsWith('.ts'),
+    );
+    expect(hasRootLevelTs).toBeTrue();
+    expect(hasNestedTs).toBeTrue();
+  },
+);
+
+tap.test(
+  '.fs.listFileTree() -> should handle edge cases with **/ patterns consistently',
+  async () => {
+    // Test that our fix ensures no duplicate files in results
+    const jsonFiles = await smartfile.fs.listFileTree(
+      path.resolve('./test/testassets/'),
+      '**/*.json',
+    );
+    const uniqueFiles = [...new Set(jsonFiles)];
+    expect(jsonFiles.length).toEqual(uniqueFiles.length);
+
+    // Test that it finds root level files with **/ patterns
+    const txtFiles = await smartfile.fs.listFileTree(
+      path.resolve('./test/testassets/'),
+      '**/*.txt',
+    );
+    // Should include both direct files and nested files
+    expect(txtFiles).toContain('mytest.txt');
+    expect(txtFiles).toContain('testfolder/testfile1.txt');
+  },
+);
+
+tap.test(
+  '.fs.fileTreeToObject -> should read a file tree into an Object',
+  async () => {
+    const fileArrayArg = await smartfile.fs.fileTreeToObject(
+      path.resolve('./test/testassets/'),
+      '**/*.txt',
+    );
+    expect(fileArrayArg[0]).toBeInstanceOf(smartfile.SmartFile);
+    expect(fileArrayArg[0].contents.toString()).toEqual(
+      fileArrayArg[0].contentBuffer.toString(),
+    );
+  },
+);
 
 tap.test('.fs.copy() -> should copy a directory', async () => {
-  await smartfile.fs.copy('./test/testassets/testfolder/', './test/testassets/temp/');
+  await smartfile.fs.copy(
+    './test/testassets/testfolder/',
+    './test/testassets/temp/',
+  );
 });
 
 tap.test('.fs.copy() -> should copy a file', async () => {
-  await smartfile.fs.copy('./test/testassets/mytest.yaml', './test/testassets/temp/mytest.yaml');
+  await smartfile.fs.copy(
+    './test/testassets/mytest.yaml',
+    './test/testassets/temp/mytest.yaml',
+  );
 });
 
 tap.test('.fs.copy() -> should copy a file and rename it', async () => {
   await smartfile.fs.copy(
     './test/testassets/mytest.yaml',
-    './test/testassets/temp/mytestRenamed.yaml'
+    './test/testassets/temp/mytestRenamed.yaml',
   );
 });
 
@@ -89,70 +172,105 @@ tap.test('.fs.remove -> should remove single files', async () => {
   await smartfile.fs.remove('./test/testassets/temp/mytestRenamed.yaml');
 });
 
-tap.test('.fs.removeSync -> should remove single files synchronouly', async () => {
-  smartfile.fs.removeSync('./test/testassets/temp/testfile1.txt');
-  expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).toBeFalse();
-});
+tap.test(
+  '.fs.removeSync -> should remove single files synchronouly',
+  async () => {
+    smartfile.fs.removeSync('./test/testassets/temp/testfile1.txt');
+    expect(
+      smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt'),
+    ).toBeFalse();
+  },
+);
 
 tap.test('.fs.removeMany -> should remove and array of files', async () => {
   smartfile.fs
-    .removeMany(['./test/testassets/temp/testfile1.txt', './test/testassets/temp/testfile2.txt'])
+    .removeMany([
+      './test/testassets/temp/testfile1.txt',
+      './test/testassets/temp/testfile2.txt',
+    ])
     .then(() => {
-      expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).toBeFalse();
-      expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).toBeFalse();
+      expect(
+        smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt'),
+      ).toBeFalse();
+      expect(
+        smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt'),
+      ).toBeFalse();
     });
 });
 
-tap.test('.fs.removeManySync -> should remove and array of single files synchronouly', async () => {
-  smartfile.fs.removeManySync([
-    './test/testassets/temp/testfile1.txt',
-    './test/testassets/temp/testfile2.txt',
-  ]);
-  expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt')).toBeFalse();
-  expect(smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt')).toBeFalse();
-});
+tap.test(
+  '.fs.removeManySync -> should remove and array of single files synchronouly',
+  async () => {
+    smartfile.fs.removeManySync([
+      './test/testassets/temp/testfile1.txt',
+      './test/testassets/temp/testfile2.txt',
+    ]);
+    expect(
+      smartfile.fs.fileExistsSync('./test/testassets/temp/testfile1.txt'),
+    ).toBeFalse();
+    expect(
+      smartfile.fs.fileExistsSync('./test/testassets/temp/testfile2.txt'),
+    ).toBeFalse();
+  },
+);
 
-tap.test('.fs.toObjectSync() -> should read an .yaml file to an object', async () => {
-  const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.yaml');
-  expect(testData.key1).toEqual('this works');
-  expect(testData.key2).toEqual('this works too');
-});
+tap.test(
+  '.fs.toObjectSync() -> should read an .yaml file to an object',
+  async () => {
+    const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.yaml');
+    expect(testData.key1).toEqual('this works');
+    expect(testData.key2).toEqual('this works too');
+  },
+);
 tap.test(
   '.fs.toObjectSync() -> should state unknown file type for unknown file types',
   async () => {
     const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.txt');
-  }
+  },
 );
 
-tap.test('.fs.toObjectSync() -> should read an .json file to an object', async () => {
-  const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.json');
-  expect(testData.key1).toEqual('this works');
-  expect(testData.key2).toEqual('this works too');
-});
+tap.test(
+  '.fs.toObjectSync() -> should read an .json file to an object',
+  async () => {
+    const testData = smartfile.fs.toObjectSync('./test/testassets/mytest.json');
+    expect(testData.key1).toEqual('this works');
+    expect(testData.key2).toEqual('this works too');
+  },
+);
 
 tap.test('.fs.toStringSync() -> should read a file to a string', async () => {
-  expect(smartfile.fs.toStringSync('./test/testassets/mytest.txt')).toEqual('Some TestString &&%$');
+  expect(smartfile.fs.toStringSync('./test/testassets/mytest.txt')).toEqual(
+    'Some TestString &&%$',
+  );
 });
 
 // ---------------------------
 // smartfile.interpreter
 // ---------------------------
 
-tap.test('.interpreter.filetype() -> should get the file type from a string', async () => {
-  expect(smartfile.interpreter.filetype('./somefolder/data.json')).toEqual('json');
-});
+tap.test(
+  '.interpreter.filetype() -> should get the file type from a string',
+  async () => {
+    expect(smartfile.interpreter.filetype('./somefolder/data.json')).toEqual(
+      'json',
+    );
+  },
+);
 
 // ---------------------------
 // smartfile.memory
 // ---------------------------
 
-tap.test('.memory.toFs() -> should write a file to disk and return a promise', async () => {
-  const localString = 'myString';
-  await smartfile.memory.toFs(
-    localString,
-    path.join(process.cwd(), './test/testassets/temp/testMemToFs.txt')
-  );
-});
+tap.test(
+  '.memory.toFs() -> should write a file to disk and return a promise',
+  async () => {
+    const localString = 'myString';
+    await smartfile.memory.toFs(
+      localString,
+      path.join(process.cwd(), './test/testassets/temp/testMemToFs.txt'),
+    );
+  },
+);
 
 tap.test(
   '.memory.toFsSync() -> should write a file to disk and return true if successfull',
@@ -160,9 +278,9 @@ tap.test(
     const localString = 'myString';
     smartfile.memory.toFsSync(
       localString,
-      path.join(process.cwd(), './test/testassets/temp/testMemToFsSync.txt')
+      path.join(process.cwd(), './test/testassets/temp/testMemToFsSync.txt'),
     );
-  }
+  },
 );
 
 // ---------------------------
@@ -172,7 +290,7 @@ tap.test(
 tap.test('.Smartfile -> should produce vinyl compatible files', async () => {
   const smartfileArray = await smartfile.fs.fileTreeToObject(
     process.cwd(),
-    './test/testassets/testfolder/**/*'
+    './test/testassets/testfolder/**/*',
   );
   const localSmartfile = smartfileArray[0];
   expect(localSmartfile).toBeInstanceOf(smartfile.SmartFile);
@@ -186,7 +304,10 @@ tap.test('.Smartfile -> should produce vinyl compatible files', async () => {
 });
 
 tap.test('should output a smartfile array to disk', async () => {
-  const smartfileArray = await smartfile.fs.fileTreeToObject('./test/testassets/testfolder/', '*');
+  const smartfileArray = await smartfile.fs.fileTreeToObject(
+    './test/testassets/testfolder/',
+    '*',
+  );
   for (const smartfileInstance of smartfileArray) {
     console.log(smartfileInstance.relative);
     console.log(smartfileInstance.path);
@@ -195,14 +316,18 @@ tap.test('should output a smartfile array to disk', async () => {
   }
   await smartfile.memory.smartfileArrayToFs(
     smartfileArray,
-    path.resolve('./test/testassets/temp/testoutput/')
+    path.resolve('./test/testassets/temp/testoutput/'),
   );
 });
 
 tap.test('should create, store and retrieve valid smartfiles', async () => {
   const fileString = 'hi there';
   const filePath = './test/testassets/utf8.txt';
-  const smartfileInstance = await smartfile.SmartFile.fromString(filePath, fileString, 'utf8');
+  const smartfileInstance = await smartfile.SmartFile.fromString(
+    filePath,
+    fileString,
+    'utf8',
+  );
   smartfileInstance.write();
   const smartfileInstance2 = await smartfile.SmartFile.fromFilePath(filePath);
   const retrievedString = smartfileInstance.contents.toString();
@@ -212,7 +337,11 @@ tap.test('should create, store and retrieve valid smartfiles', async () => {
 tap.test('should get a hash', async () => {
   const fileString = 'hi there';
   const filePath = './test/testassets/utf8.txt';
-  const smartfileInstance = await smartfile.SmartFile.fromString(filePath, fileString, 'utf8');
+  const smartfileInstance = await smartfile.SmartFile.fromString(
+    filePath,
+    fileString,
+    'utf8',
+  );
   const hash = await smartfileInstance.getHash();
   console.log(hash);
 });

test/test.virtualdirectory.ts

@@ -1,14 +1,18 @@
-import { tap, expect } from '@push.rocks/tapbundle';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
 
 import * as smartfile from '../ts/index.js';
 
 tap.test('should create a virtualdirectory', async () => {
-  const virtualDir = await smartfile.VirtualDirectory.fromFsDirPath('./test/testassets/testfolder');
+  const virtualDir = await smartfile.VirtualDirectory.fromFsDirPath(
+    './test/testassets/testfolder',
+  );
   expect(virtualDir.smartfileArray.length).toEqual(4);
 });
 
 tap.test('should write to a directory', async () => {
-  const virtualDir = await smartfile.VirtualDirectory.fromFsDirPath('./test/testassets/testfolder');
+  const virtualDir = await smartfile.VirtualDirectory.fromFsDirPath(
+    './test/testassets/testfolder',
+  );
   virtualDir.saveToDisk('./test/testassets/test');
 });
 

test/testassets/mytest.json

@@ -5,4 +5,3 @@
     "nestedkey1": "hello"
   }
 }
-

test/testassets/mytest.yaml

@@ -1,4 +1,4 @@
 key1: this works
 key2: this works too
 key3:
-  nestedkey1: hello
+  nestedkey1: hello

test/testassets/temp/mytest.json

@@ -5,4 +5,3 @@
     "nestedkey1": "hello"
   }
 }
-

test/testassets/temp/mytest.yaml

@@ -1,4 +1,4 @@
 key1: this works
 key2: this works too
 key3:
-  nestedkey1: hello
+  nestedkey1: hello

test/testassets/temp/test/testassets/mytest.json

@@ -5,4 +5,3 @@
     "nestedkey1": "hello"
   }
 }
-

ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@push.rocks/smartfile',
-  version: '11.0.14',
-  description: 'provides a robust suite of tools for managing files in Node.js using TypeScript.'
+  version: '11.2.6',
+  description: 'Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.'
 }

ts/classes.smartfile.ts

@@ -20,7 +20,10 @@ export class SmartFile extends plugins.smartjson.Smartjson {
    * creates a Smartfile from a filePath
    * @param filePath
    */
-  public static async fromFilePath(filePath: string, baseArg: string = process.cwd()) {
+  public static async fromFilePath(
+    filePath: string,
+    baseArg: string = process.cwd(),
+  ) {
     filePath = plugins.path.resolve(filePath);
     const fileBuffer = fs.toBufferSync(filePath);
     const smartfile = new SmartFile({
@@ -34,7 +37,7 @@ export class SmartFile extends plugins.smartjson.Smartjson {
   public static async fromBuffer(
     filePath: string,
     contentBufferArg: Buffer,
-    baseArg: string = process.cwd()
+    baseArg: string = process.cwd(),
   ) {
     const smartfile = new SmartFile({
       contentBuffer: contentBufferArg,
@@ -49,7 +52,7 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     filePath: string,
     contentStringArg: string,
     encodingArg: 'utf8' | 'binary',
-    baseArg = process.cwd()
+    baseArg = process.cwd(),
   ) {
     const smartfile = new SmartFile({
       contentBuffer: Buffer.from(contentStringArg, encodingArg),
@@ -73,7 +76,7 @@ export class SmartFile extends plugins.smartjson.Smartjson {
   public static async fromStream(
     stream: plugins.stream.Readable,
     filePath: string,
-    baseArg: string = process.cwd()
+    baseArg: string = process.cwd(),
   ): Promise<SmartFile> {
     return new Promise<SmartFile>((resolve, reject) => {
       const chunks: Buffer[] = [];
@@ -91,9 +94,13 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     });
   }
 
-  public static async fromUrl (urlArg: string) {
-    const response = await plugins.smartrequest.getBinary(urlArg);
-    const smartfile = await SmartFile.fromBuffer(urlArg, response.body);
+  public static async fromUrl(urlArg: string) {
+    const response = await plugins.smartrequest.SmartRequest.create()
+      .url(urlArg)
+      .accept('binary')
+      .get();
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const smartfile = await SmartFile.fromBuffer(urlArg, buffer);
     return smartfile;
   }
 
@@ -159,7 +166,10 @@ export class SmartFile extends plugins.smartjson.Smartjson {
    * set contents from string
    * @param contentString
    */
-  public setContentsFromString(contentString: string, encodingArg: 'utf8' | 'binary' = 'utf8') {
+  public setContentsFromString(
+    contentString: string,
+    encodingArg: 'utf8' | 'binary' = 'utf8',
+  ) {
     this.contents = Buffer.from(contentString, encodingArg);
   }
 
@@ -169,7 +179,10 @@ export class SmartFile extends plugins.smartjson.Smartjson {
    * - no argument write to exactly where the file was picked up
    */
   public async write() {
-    let writePath = plugins.smartpath.transform.makeAbsolute(this.path, this.base);
+    let writePath = plugins.smartpath.transform.makeAbsolute(
+      this.path,
+      this.base,
+    );
     console.log(`writing to ${writePath}`);
     await memory.toFs(this.contentBuffer, writePath);
   }
@@ -202,7 +215,9 @@ export class SmartFile extends plugins.smartjson.Smartjson {
    * read file from disk
    */
   public async read() {
-    this.contentBuffer = await fs.toBuffer(plugins.path.join(this.base, this.path));
+    this.contentBuffer = await fs.toBuffer(
+      plugins.path.join(this.base, this.path),
+    );
   }
 
   /**
@@ -212,6 +227,52 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     await fs.remove(plugins.path.join(this.base, this.path));
   }
 
+  /**
+   * Renames the file to the specified new name.
+   * - Updates the `path` property with the new name.
+   * - Writes the file to the new location if it exists on disk.
+   * @param newName The new name of the file (including extension if applicable).
+   * @param writeToDisk (optional) If true, also renames the file on the disk.
+   * @returns The updated file path after renaming.
+   */
+  public async rename(
+    newName: string,
+    writeToDisk: boolean = false,
+  ): Promise<string> {
+    // Validate the new name
+    if (!newName || typeof newName !== 'string') {
+      throw new Error('Invalid new name provided.');
+    }
+
+    // Extract the directory path
+    const oldFilePath = this.path;
+    const dirPath = plugins.path.dirname(this.path);
+
+    // Create the new file path
+    const newFilePath = plugins.path.join(dirPath, newName);
+
+    // Update the `path` property
+    this.path = newFilePath;
+
+    // Optionally write the renamed file to disk
+    if (writeToDisk) {
+      const oldAbsolutePath = plugins.smartpath.transform.makeAbsolute(
+        oldFilePath,
+        this.base,
+      );
+      const newAbsolutePath = plugins.smartpath.transform.makeAbsolute(
+        newFilePath,
+        this.base,
+      );
+
+      // Rename the file on disk
+      await plugins.fsExtra.rename(oldAbsolutePath, newAbsolutePath);
+    }
+
+    // Return the new path
+    return this.path;
+  }
+
   // -----------------------------------------------
   // vinyl compatibility
   // -----------------------------------------------
@@ -273,8 +334,12 @@ export class SmartFile extends plugins.smartjson.Smartjson {
 
   public async getHash(typeArg: 'path' | 'content' | 'all' = 'all') {
     const pathHash = await plugins.smarthash.sha256FromString(this.path);
-    const contentHash = await plugins.smarthash.sha256FromBuffer(this.contentBuffer);
-    const combinedHash = await plugins.smarthash.sha256FromString(pathHash + contentHash);
+    const contentHash = await plugins.smarthash.sha256FromBuffer(
+      this.contentBuffer,
+    );
+    const combinedHash = await plugins.smarthash.sha256FromString(
+      pathHash + contentHash,
+    );
     switch (typeArg) {
       case 'path':
         return pathHash;
@@ -292,7 +357,9 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     this.path = this.path.replace(new RegExp(oldFileName + '$'), fileNameArg);
   }
 
-  public async editContentAsString(editFuncArg: (fileStringArg: string) => Promise<string>) {
+  public async editContentAsString(
+    editFuncArg: (fileStringArg: string) => Promise<string>,
+  ) {
     const newFileString = await editFuncArg(this.contentBuffer.toString());
     this.contentBuffer = Buffer.from(newFileString);
   }
@@ -306,4 +373,11 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     stream.push(null); // Push null to signify the end of the stream (EOF)
     return stream;
   }
+
+  /**
+   * Returns the size of the file in bytes
+   */
+  public async getSize(): Promise<number> {
+    return this.contentBuffer.length;
+  }
 }

ts/classes.streamfile.ts

@@ -3,44 +3,51 @@ import * as smartfileFs from './fs.js';
 import * as smartfileFsStream from './fsstream.js';
 import { Readable } from 'stream';
 
-type TStreamSource = (streamFile: StreamFile) => Promise<Readable>;
+type TStreamSource = (streamFile: StreamFile) => Promise<Readable | ReadableStream>;
 
 /**
  * The StreamFile class represents a file as a stream.
  * It allows creating streams from a file path, a URL, or a buffer.
  */
 export class StreamFile {
-  // INSTANCE
-  relativeFilePath?: string;
-  private streamSource: TStreamSource;
-
-  // enable stream based multi use
-  private cachedStreamBuffer?: Buffer;
-  public multiUse: boolean;
-  public used: boolean = false;
-
-  private constructor(streamSource: TStreamSource, relativeFilePath?: string) {
-    this.streamSource = streamSource;
-    this.relativeFilePath = relativeFilePath;
-  }
-
   // STATIC
 
   public static async fromPath(filePath: string): Promise<StreamFile> {
-    const streamSource: TStreamSource = async (stremFileArg) => smartfileFsStream.createReadStream(filePath);
+    const streamSource: TStreamSource = async (streamFileArg) =>
+      smartfileFsStream.createReadStream(filePath);
     const streamFile = new StreamFile(streamSource, filePath);
     streamFile.multiUse = true;
+    streamFile.byteLengthComputeFunction = async () => {
+      const stats = await smartfileFs.stat(filePath);
+      return stats.size;
+    };
     return streamFile;
   }
 
   public static async fromUrl(url: string): Promise<StreamFile> {
-    const streamSource: TStreamSource = async (streamFileArg) => plugins.smartrequest.getStream(url); // Replace with actual plugin method
+    const streamSource: TStreamSource = async (streamFileArg) => {
+      const response = await plugins.smartrequest.SmartRequest.create()
+        .url(url)
+        .get();
+      return response.stream();
+    };
     const streamFile = new StreamFile(streamSource);
     streamFile.multiUse = true;
+    streamFile.byteLengthComputeFunction = async () => {
+      const response = await plugins.smartrequest.SmartRequest.create()
+        .url(url)
+        .accept('binary')
+        .get();
+      const buffer = Buffer.from(await response.arrayBuffer());
+      return buffer.length;
+    };
     return streamFile;
   }
 
-  public static fromBuffer(buffer: Buffer, relativeFilePath?: string): StreamFile {
+  public static fromBuffer(
+    buffer: Buffer,
+    relativeFilePath?: string,
+  ): StreamFile {
     const streamSource: TStreamSource = async (streamFileArg) => {
       const stream = new Readable();
       stream.push(buffer);
@@ -49,6 +56,7 @@ export class StreamFile {
     };
     const streamFile = new StreamFile(streamSource, relativeFilePath);
     streamFile.multiUse = true;
+    streamFile.byteLengthComputeFunction = async () => buffer.length;
     return streamFile;
   }
 
@@ -59,7 +67,11 @@ export class StreamFile {
    * @param multiUse If true, the stream can be read multiple times, caching its content.
    * @returns A StreamFile instance.
    */
-  public static fromStream(stream: Readable, relativeFilePath?: string, multiUse: boolean = false): StreamFile {
+  public static fromStream(
+    stream: Readable,
+    relativeFilePath?: string,
+    multiUse: boolean = false,
+  ): StreamFile {
     const streamSource: TStreamSource = (streamFileArg) => {
       if (streamFileArg.multiUse) {
         // If multi-use is enabled and we have cached content, create a new readable stream from the buffer
@@ -91,6 +103,21 @@ export class StreamFile {
     return streamFile;
   }
 
+  // INSTANCE
+  relativeFilePath?: string;
+  private streamSource: TStreamSource;
+
+  // enable stream based multi use
+  private cachedStreamBuffer?: Buffer;
+  public multiUse: boolean;
+  public used: boolean = false;
+  public byteLengthComputeFunction: () => Promise<number>;
+
+  private constructor(streamSource: TStreamSource, relativeFilePath?: string) {
+    this.streamSource = streamSource;
+    this.relativeFilePath = relativeFilePath;
+  }
+
   // METHODS
 
   private checkMultiUse() {
@@ -104,7 +131,16 @@ export class StreamFile {
    * Creates a new readable stream from the source.
    */
   public async createReadStream(): Promise<Readable> {
-    return this.streamSource(this);
+    const stream = await this.streamSource(this);
+    
+    // Check if it's a Web ReadableStream and convert to Node.js Readable
+    if (stream && typeof (stream as any).getReader === 'function') {
+      // This is a Web ReadableStream, convert it to Node.js Readable
+      return Readable.fromWeb(stream as any);
+    }
+    
+    // It's already a Node.js Readable stream
+    return stream as Readable;
   }
 
   /**
@@ -149,4 +185,15 @@ export class StreamFile {
     const contentBuffer = await this.getContentAsBuffer();
     return contentBuffer.toString(formatArg);
   }
+
+  /**
+   * Returns the size of the file content in bytes.
+   */
+  public async getSize(): Promise<number> {
+    if (this.byteLengthComputeFunction) {
+      return this.byteLengthComputeFunction();
+    } else {
+      return null;
+    }
+  }
 }

ts/classes.virtualdirectory.ts

@@ -2,33 +2,33 @@ import { SmartFile } from './classes.smartfile.js';
 import * as plugins from './plugins.js';
 import * as fs from './fs.js';
 
-
 export interface IVirtualDirectoryConstructorOptions {
-  mode: ''
+  mode: '';
 }
 
 /**
  * a virtual directory exposes a fs api
  */
 export class VirtualDirectory {
-
-  consstructor(options = {}) {
-
-  }
+  consstructor(options = {}) {}
 
   // STATIC
-  public static async fromFsDirPath(pathArg: string): Promise<VirtualDirectory> {
+  public static async fromFsDirPath(
+    pathArg: string,
+  ): Promise<VirtualDirectory> {
     const newVirtualDir = new VirtualDirectory();
     newVirtualDir.addSmartfiles(await fs.fileTreeToObject(pathArg, '**/*'));
     return newVirtualDir;
   }
 
   public static async fromVirtualDirTransferableObject(
-    virtualDirTransferableObjectArg: plugins.smartfileInterfaces.VirtualDirTransferableObject
+    virtualDirTransferableObjectArg: plugins.smartfileInterfaces.VirtualDirTransferableObject,
   ): Promise<VirtualDirectory> {
     const newVirtualDir = new VirtualDirectory();
     for (const fileArg of virtualDirTransferableObjectArg.files) {
-      newVirtualDir.addSmartfiles([SmartFile.enfoldFromJson(fileArg) as SmartFile]);
+      newVirtualDir.addSmartfiles([
+        SmartFile.enfoldFromJson(fileArg) as SmartFile,
+      ]);
     }
     return newVirtualDir;
   }
@@ -52,7 +52,9 @@ export class VirtualDirectory {
 
   public async toVirtualDirTransferableObject(): Promise<plugins.smartfileInterfaces.VirtualDirTransferableObject> {
     return {
-      files: this.smartfileArray.map((smartfileArg) => smartfileArg.foldToJson()),
+      files: this.smartfileArray.map((smartfileArg) =>
+        smartfileArg.foldToJson(),
+      ),
     };
   }
 
@@ -78,7 +80,10 @@ export class VirtualDirectory {
     return newVirtualDir;
   }
 
-  public async addVirtualDirectory(virtualDir: VirtualDirectory, newRoot: string): Promise<void> {
+  public async addVirtualDirectory(
+    virtualDir: VirtualDirectory,
+    newRoot: string,
+  ): Promise<void> {
     for (const file of virtualDir.smartfileArray) {
       file.path = plugins.path.join(newRoot, file.path);
     }

ts/fs.ts

@@ -72,25 +72,47 @@ export const isFile = (pathArg): boolean => {
 ===============================================================*/
 
 /**
- * copies a file from A to B on the local disk
+ * copies a file or directory from A to B on the local disk
  */
-export const copy = async (fromArg: string, toArg: string): Promise<boolean> => {
-  const done = plugins.smartpromise.defer<boolean>();
-  plugins.fsExtra.copy(fromArg, toArg, {}, (err) => {
-    if (err) {
-      throw new Error(`Could not copy from ${fromArg} to ${toArg}: ${err}`);
-    }
-    done.resolve(true);
-  });
-  return done.promise;
+export const copy = async (
+  fromArg: string,
+  toArg: string,
+  optionsArg?: plugins.fsExtra.CopyOptions & { replaceTargetDir?: boolean },
+): Promise<void> => {
+  if (
+    optionsArg?.replaceTargetDir &&
+    isDirectory(fromArg) &&
+    isDirectory(toArg)
+  ) {
+    await remove(toArg);
+  }
+  return await plugins.fsExtra.copy(
+    fromArg,
+    toArg,
+    optionsArg as plugins.fsExtra.CopyOptions,
+  );
 };
 
 /**
- * copies a file SYNCHRONOUSLY from A to B on the local disk
+ * copies a file or directory SYNCHRONOUSLY from A to B on the local disk
  */
-export const copySync = (fromArg: string, toArg: string): boolean => {
-  plugins.fsExtra.copySync(fromArg, toArg);
-  return true;
+export const copySync = (
+  fromArg: string,
+  toArg: string,
+  optionsArg?: plugins.fsExtra.CopyOptionsSync & { replaceTargetDir?: boolean },
+): void => {
+  if (
+    optionsArg?.replaceTargetDir &&
+    isDirectory(fromArg) &&
+    isDirectory(toArg)
+  ) {
+    removeSync(toArg);
+  }
+  return plugins.fsExtra.copySync(
+    fromArg,
+    toArg,
+    optionsArg as plugins.fsExtra.CopyOptionsSync,
+  );
 };
 
 /**
@@ -132,7 +154,10 @@ export const ensureEmptyDirSync = (dirPathArg: string) => {
  * @returns Promise<void>
  * @exec ASYNC
  */
-export const ensureFile = async (filePathArg, initFileStringArg): Promise<void> => {
+export const ensureFile = async (
+  filePathArg,
+  initFileStringArg,
+): Promise<void> => {
   ensureFileSync(filePathArg, initFileStringArg);
 };
 
@@ -143,7 +168,10 @@ export const ensureFile = async (filePathArg, initFileStringArg): Promise<void>
  * @returns Promise<void>
  * @exec SYNC
  */
-export const ensureFileSync = (filePathArg: string, initFileStringArg: string): void => {
+export const ensureFileSync = (
+  filePathArg: string,
+  initFileStringArg: string,
+): void => {
   if (fileExistsSync(filePathArg)) {
     return null;
   } else {
@@ -190,7 +218,8 @@ export const removeManySync = (filePathArrayArg: string[]): void => {
 ===============================================================*/
 
 /**
- *
+ * reads a file content to an object
+ * good for JSON, YAML, TOML, etc.
  * @param filePathArg
  * @param fileTypeArg
  * @returns {any}
@@ -198,16 +227,26 @@ export const removeManySync = (filePathArrayArg: string[]): void => {
 export const toObjectSync = (filePathArg, fileTypeArg?) => {
   const fileString = plugins.fsExtra.readFileSync(filePathArg, 'utf8');
   let fileType;
-  fileTypeArg ? (fileType = fileTypeArg) : (fileType = interpreter.filetype(filePathArg));
-  return interpreter.objectFile(fileString, fileType);
+  fileTypeArg
+    ? (fileType = fileTypeArg)
+    : (fileType = interpreter.filetype(filePathArg));
+  try {
+    return interpreter.objectFile(fileString, fileType);
+  } catch (err) {
+    err.message = `Failed to read file at ${filePathArg}` + err.message;
+    throw err;
+  }
 };
 
 /**
  * reads a file content to a String
  */
 export const toStringSync = (filePath: string): string => {
-  const encoding = plugins.smartmime.getEncoding(filePath);
-  let fileString: string | Buffer = plugins.fsExtra.readFileSync(filePath, encoding);
+  const encoding = plugins.smartmime.getEncodingForPathSync(filePath);
+  let fileString: string | Buffer = plugins.fsExtra.readFileSync(
+    filePath,
+    encoding,
+  );
   if (Buffer.isBuffer(fileString)) {
     fileString = fileString.toString('binary');
   }
@@ -234,7 +273,10 @@ export const toReadStream = (filePath: string): plugins.fs.ReadStream => {
   return plugins.fsExtra.createReadStream(filePath);
 };
 
-export const fileTreeToHash = async (dirPathArg: string, miniMatchFilter: string) => {
+export const fileTreeToHash = async (
+  dirPathArg: string,
+  miniMatchFilter: string,
+) => {
   const fileTreeObject = await fileTreeToObject(dirPathArg, miniMatchFilter);
   let combinedString = '';
   for (const smartfile of fileTreeObject) {
@@ -249,7 +291,10 @@ export const fileTreeToHash = async (dirPathArg: string, miniMatchFilter: string
  * @param dirPathArg the directory to start from
  * @param miniMatchFilter a minimatch filter of what files to include
  */
-export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: string) => {
+export const fileTreeToObject = async (
+  dirPathArg: string,
+  miniMatchFilter: string,
+) => {
   // handle absolute miniMatchFilter
   let dirPath: string;
   if (plugins.path.isAbsolute(miniMatchFilter)) {
@@ -276,7 +321,7 @@ export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: stri
         contentBuffer: fileBuffer,
         base: dirPath,
         path: filePath,
-      })
+      }),
     );
   }
   return smartfileArray;
@@ -286,7 +331,10 @@ export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: stri
  * lists Folders in a directory on local disk
  * @returns Promise with an array that contains the folder names
  */
-export const listFolders = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
+export const listFolders = async (
+  pathArg: string,
+  regexFilter?: RegExp,
+): Promise<string[]> => {
   return listFoldersSync(pathArg, regexFilter);
 };
 
@@ -294,9 +342,14 @@ export const listFolders = async (pathArg: string, regexFilter?: RegExp): Promis
  * lists Folders SYNCHRONOUSLY in a directory on local disk
  * @returns an array with the folder names as strings
  */
-export const listFoldersSync = (pathArg: string, regexFilter?: RegExp): string[] => {
+export const listFoldersSync = (
+  pathArg: string,
+  regexFilter?: RegExp,
+): string[] => {
   let folderArray = plugins.fsExtra.readdirSync(pathArg).filter((file) => {
-    return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isDirectory();
+    return plugins.fsExtra
+      .statSync(plugins.path.join(pathArg, file))
+      .isDirectory();
   });
   if (regexFilter) {
     folderArray = folderArray.filter((fileItem) => {
@@ -310,7 +363,10 @@ export const listFoldersSync = (pathArg: string, regexFilter?: RegExp): string[]
  * lists Files in a directory on local disk
  * @returns Promise
  */
-export const listFiles = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
+export const listFiles = async (
+  pathArg: string,
+  regexFilter?: RegExp,
+): Promise<string[]> => {
   return listFilesSync(pathArg, regexFilter);
 };
 
@@ -318,7 +374,10 @@ export const listFiles = async (pathArg: string, regexFilter?: RegExp): Promise<
  * lists Files SYNCHRONOUSLY in a directory on local disk
  * @returns an array with the folder names as strings
  */
-export const listFilesSync = (pathArg: string, regexFilter?: RegExp): string[] => {
+export const listFilesSync = (
+  pathArg: string,
+  regexFilter?: RegExp,
+): string[] => {
   let fileArray = plugins.fsExtra.readdirSync(pathArg).filter((file) => {
     return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
   });
@@ -334,7 +393,10 @@ export const listFilesSync = (pathArg: string, regexFilter?: RegExp): string[] =
  * lists all items (folders AND files) in a directory on local disk
  * @returns Promise<string[]>
  */
-export const listAllItems = async (pathArg: string, regexFilter?: RegExp): Promise<string[]> => {
+export const listAllItems = async (
+  pathArg: string,
+  regexFilter?: RegExp,
+): Promise<string[]> => {
   return listAllItemsSync(pathArg, regexFilter);
 };
 
@@ -343,7 +405,10 @@ export const listAllItems = async (pathArg: string, regexFilter?: RegExp): Promi
  * @returns an array with the folder names as strings
  * @executes SYNC
  */
-export const listAllItemsSync = (pathArg: string, regexFilter?: RegExp): string[] => {
+export const listAllItemsSync = (
+  pathArg: string,
+  regexFilter?: RegExp,
+): string[] => {
   let allItmesArray = plugins.fsExtra.readdirSync(pathArg).filter((file) => {
     return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
   });
@@ -363,7 +428,7 @@ export const listAllItemsSync = (pathArg: string, regexFilter?: RegExp): string[
 export const listFileTree = async (
   dirPathArg: string,
   miniMatchFilter: string,
-  absolutePathsBool: boolean = false
+  absolutePathsBool: boolean = false,
 ): Promise<string[]> => {
   // handle absolute miniMatchFilter
   let dirPath: string;
@@ -379,7 +444,28 @@ export const listFileTree = async (
     dot: true,
   };
 
-  let fileList = await plugins.glob.glob(miniMatchFilter, options);
+  // Fix inconsistent **/* glob behavior across systems
+  // Some glob implementations don't include root-level files when using **/*
+  // To ensure consistent behavior, we expand **/* patterns to include both root and nested files
+  let patterns: string[];
+  if (miniMatchFilter.startsWith('**/')) {
+    // Extract the part after **/ (e.g., "*.ts" from "**/*.ts")
+    const rootPattern = miniMatchFilter.substring(3);
+    // Use both the root pattern and the original pattern to ensure we catch everything
+    patterns = [rootPattern, miniMatchFilter];
+  } else {
+    patterns = [miniMatchFilter];
+  }
+
+  // Collect results from all patterns
+  const allFiles = new Set<string>();
+  for (const pattern of patterns) {
+    const files = await plugins.glob.glob(pattern, options);
+    files.forEach((file) => allFiles.add(file));
+  }
+
+  let fileList = Array.from(allFiles).sort();
+
   if (absolutePathsBool) {
     fileList = fileList.map((filePath) => {
       return plugins.path.resolve(plugins.path.join(dirPath, filePath));
@@ -391,53 +477,187 @@ export const listFileTree = async (
 
 /**
  * Watches for file stability before resolving the promise.
+ * Ensures that the directory/file exists before setting up the watcher.
+ *
+ * **New behavior**: If the given path is a directory, this function will:
+ *  1. Wait for that directory to exist (creating a timeout if needed).
+ *  2. Watch the directory until at least one file appears.
+ *  3. Then wait for the first file in the directory to stabilize before resolving.
+ *
+ * @param fileOrDirPathArg The path of the file or directory to monitor.
+ * @param timeoutMs The maximum time to wait for the file to stabilize (in milliseconds). Default is 60 seconds.
+ * @returns A promise that resolves when the target is stable or rejects on timeout/error.
  */
-export const waitForFileToBeReady = (filePathArg: string): Promise<void> => {
-  return new Promise(async (resolve, reject) => {
+export const waitForFileToBeReady = async (
+  fileOrDirPathArg: string,
+  timeoutMs: number = 60000,
+): Promise<void> => {
+  const startTime = Date.now();
+
+  /**
+   * Ensure that a path (file or directory) exists. If it doesn't yet exist,
+   * wait until it does (or time out).
+   * @param pathToCheck The file or directory path to check.
+   */
+  const ensurePathExists = async (pathToCheck: string): Promise<void> => {
+    while (true) {
+      try {
+        await plugins.smartpromise.fromCallback((cb) =>
+          plugins.fs.access(pathToCheck, plugins.fs.constants.F_OK, cb),
+        );
+        return;
+      } catch (err: any) {
+        if (err.code !== 'ENOENT') {
+          throw err; // Propagate unexpected errors
+        }
+        if (Date.now() - startTime > timeoutMs) {
+          throw new Error(`Timeout waiting for path to exist: ${pathToCheck}`);
+        }
+        await plugins.smartdelay.delayFor(500);
+      }
+    }
+  };
+
+  /**
+   * Checks if a file (not directory) is stable by comparing sizes
+   * across successive checks.
+   * @param filePathArg The path of the file to check.
+   * @returns A promise that resolves once the file stops changing.
+   */
+  const waitForSingleFileToBeStable = async (
+    filePathArg: string,
+  ): Promise<void> => {
     let lastFileSize = -1;
     let fileIsStable = false;
 
+    // We'll create a helper for repeated stats-checking logic
     const checkFileStability = async () => {
-      let currentFileSize: number;
-      const deferred = plugins.smartpromise.defer();
-      plugins.fs.stat(filePathArg, (err, stats) => {
-        if (err) {
-          fileIsStable = true;
-          watcher.close();
-          reject(err);
-          return;
+      try {
+        const stats = await plugins.smartpromise.fromCallback<plugins.fs.Stats>(
+          (cb) => plugins.fs.stat(filePathArg, cb),
+        );
+        if (stats.isDirectory()) {
+          // If it unexpectedly turns out to be a directory here, throw
+          throw new Error(
+            `Expected a file but found a directory: ${filePathArg}`,
+          );
+        }
+        if (stats.size === lastFileSize) {
+          fileIsStable = true;
+        } else {
+          lastFileSize = stats.size;
+          fileIsStable = false;
+        }
+      } catch (err: any) {
+        // Ignore only if file not found
+        if (err.code !== 'ENOENT') {
+          throw err;
         }
-        currentFileSize = stats.size;
-        deferred.resolve();
-      });
-      await deferred.promise;
-      if (currentFileSize === lastFileSize) {
-        fileIsStable = true;
-        await plugins.smartdelay.delayFor(100);
-        resolve();
       }
-      lastFileSize = currentFileSize;
     };
 
-    const watcher = plugins.fs.watch(filePathArg, (eventType, filename) => {
-      if (eventType === 'change') {
-        checkFileStability();
+    // Ensure file exists first
+    await ensurePathExists(filePathArg);
+
+    // Set up a watcher on the file itself
+    const fileWatcher = plugins.fs.watch(
+      filePathArg,
+      { persistent: true },
+      async () => {
+        if (!fileIsStable) {
+          await checkFileStability();
+        }
+      },
+    );
+
+    try {
+      // Poll until stable or timeout
+      while (!fileIsStable) {
+        if (Date.now() - startTime > timeoutMs) {
+          throw new Error(
+            `Timeout waiting for file to stabilize: ${filePathArg}`,
+          );
+        }
+        await checkFileStability();
+        if (!fileIsStable) {
+          await plugins.smartdelay.delayFor(1000);
+        }
       }
-    });
+    } finally {
+      fileWatcher.close();
+    }
+  };
 
-    watcher.on('error', (error) => {
-      watcher.close();
-      reject(error);
-    });
+  /**
+   * Main logic: check if we have a directory or file at fileOrDirPathArg.
+   * If directory, wait for first file in the directory to appear and stabilize.
+   * If file, do the old single-file wait logic.
+   */
+  const statsForGivenPath = await (async () => {
+    try {
+      await ensurePathExists(fileOrDirPathArg);
+      return await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
+        plugins.fs.stat(fileOrDirPathArg, cb),
+      );
+    } catch (err) {
+      // If there's an error (including timeout), just rethrow
+      throw err;
+    }
+  })();
 
-    while (!fileIsStable) {
-      await checkFileStability();
-      if (!fileIsStable) {
-        await plugins.smartdelay.delayFor(5000);
+  if (!statsForGivenPath.isDirectory()) {
+    // It's a file – just do the single-file stability wait
+    await waitForSingleFileToBeStable(fileOrDirPathArg);
+    return;
+  }
+
+  // Otherwise, it's a directory. Wait for the first file inside to appear and be stable
+  const dirPath = fileOrDirPathArg;
+
+  // Helper to find the first file in the directory if it exists
+  const getFirstFileInDirectory = async (): Promise<string | null> => {
+    const entries = await plugins.smartpromise.fromCallback<string[]>((cb) =>
+      plugins.fs.readdir(dirPath, cb),
+    );
+    // We only want actual files, not subdirectories
+    for (const entry of entries) {
+      const entryPath = plugins.path.join(dirPath, entry);
+      const entryStats =
+        await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
+          plugins.fs.stat(entryPath, cb),
+        );
+      if (entryStats.isFile()) {
+        return entryPath;
       }
     }
-    watcher.close();
-  });
+    return null;
+  };
+
+  // Wait for a file to appear in this directory
+  let firstFilePath = await getFirstFileInDirectory();
+  if (!firstFilePath) {
+    // Set up a watcher on the directory to see if a file appears
+    const directoryWatcher = plugins.fs.watch(dirPath, { persistent: true });
+    try {
+      // We'll poll for the existence of a file in that directory
+      while (!firstFilePath) {
+        if (Date.now() - startTime > timeoutMs) {
+          throw new Error(
+            `Timeout waiting for a file to appear in directory: ${dirPath}`,
+          );
+        }
+        firstFilePath = await getFirstFileInDirectory();
+        if (!firstFilePath) {
+          await plugins.smartdelay.delayFor(1000);
+        }
+      }
+    } finally {
+      directoryWatcher.close();
+    }
+  }
+
+  // Now that we have a file path, wait for that file to stabilize
+  await waitForSingleFileToBeStable(firstFilePath);
 };
 
 /**
@@ -451,7 +671,7 @@ export let toFs = async (
   filePathArg: string,
   optionsArg: {
     respectRelative?: boolean;
-  } = {}
+  } = {},
 ) => {
   const done = plugins.smartpromise.defer();
 
@@ -481,11 +701,15 @@ export let toFs = async (
     throw new Error('fileContent is neither string nor Smartfile');
   }
   await ensureDir(plugins.path.parse(filePath).dir);
-  plugins.fsExtra.writeFile(filePath, fileContent, { encoding: fileEncoding }, done.resolve);
+  plugins.fsExtra.writeFile(
+    filePath,
+    fileContent,
+    { encoding: fileEncoding },
+    done.resolve,
+  );
   return await done.promise;
 };
 
-
-
-
-
+export const stat = async (filePathArg: string) => {
+  return plugins.fsPromises.stat(filePathArg);
+};

ts/fsstream.ts

@@ -13,17 +13,17 @@ export const createWriteStream = (pathArg: string) => {
 
 export const processFile = async (
   filePath: string,
-  asyncFunc: (fileStream: plugins.stream.Readable) => Promise<void>
+  asyncFunc: (fileStream: plugins.stream.Readable) => Promise<void>,
 ): Promise<void> => {
   return new Promise((resolve, reject) => {
     const fileStream = createReadStream(filePath);
     asyncFunc(fileStream).then(resolve).catch(reject);
   });
-}
+};
 
 export const processDirectory = async (
   directoryPath: string,
-  asyncFunc: (fileStream: plugins.stream.Readable) => Promise<void>
+  asyncFunc: (fileStream: plugins.stream.Readable) => Promise<void>,
 ): Promise<void> => {
   const files = plugins.fs.readdirSync(directoryPath, { withFileTypes: true });
 
@@ -41,12 +41,15 @@ export const processDirectory = async (
 /**
  * Checks if a file is ready to be streamed (exists and is not empty).
  */
-export const isFileReadyForStreaming = async (filePathArg: string): Promise<boolean> => {
+export const isFileReadyForStreaming = async (
+  filePathArg: string,
+): Promise<boolean> => {
   try {
     const stats = await plugins.fs.promises.stat(filePathArg);
     return stats.size > 0;
   } catch (error) {
-    if (error.code === 'ENOENT') { // File does not exist
+    if (error.code === 'ENOENT') {
+      // File does not exist
       return false;
     }
     throw error; // Rethrow other unexpected errors
@@ -56,7 +59,9 @@ export const isFileReadyForStreaming = async (filePathArg: string): Promise<bool
 /**
  * Waits for a file to be ready for streaming (exists and is not empty).
  */
-export const waitForFileToBeReadyForStreaming = (filePathArg: string): Promise<void> => {
+export const waitForFileToBeReadyForStreaming = (
+  filePathArg: string,
+): Promise<void> => {
   return new Promise((resolve, reject) => {
     // Normalize and resolve the file path
     const filePath = plugins.path.resolve(filePathArg);
@@ -80,11 +85,15 @@ export const waitForFileToBeReadyForStreaming = (filePathArg: string): Promise<v
     };
 
     // Set up file watcher
-    const watcher = plugins.fs.watch(filePath, { persistent: false }, (eventType) => {
-      if (eventType === 'change' || eventType === 'rename') {
-        checkFile(resolve, reject);
-      }
-    });
+    const watcher = plugins.fs.watch(
+      filePath,
+      { persistent: false },
+      (eventType) => {
+        if (eventType === 'change' || eventType === 'rename') {
+          checkFile(resolve, reject);
+        }
+      },
+    );
 
     // Check file immediately in case it's already ready
     checkFile(resolve, reject);
@@ -105,7 +114,11 @@ export class SmartReadStream extends plugins.stream.Readable {
   private endDelay: number;
   private reading: boolean = false;
 
-  constructor(filePath: string, endDelay = 60000, opts?: plugins.stream.ReadableOptions) {
+  constructor(
+    filePath: string,
+    endDelay = 60000,
+    opts?: plugins.stream.ReadableOptions,
+  ) {
     super(opts);
     this.filePath = filePath;
     this.endDelay = endDelay;
@@ -165,26 +178,33 @@ export class SmartReadStream extends plugins.stream.Readable {
         this.emit('error', err);
         return;
       }
-      plugins.fs.read(fd, buffer, 0, chunkSize, this.lastReadSize, (err, bytesRead, buffer) => {
-        if (err) {
-          this.emit('error', err);
-          return;
-        }
-
-        if (bytesRead > 0) {
-          this.lastReadSize += bytesRead;
-          this.push(buffer.slice(0, bytesRead)); // Push the data onto the stream
-        } else {
-          this.reading = false; // No more data to read for now
-          this.resetEndTimeout();
-        }
-
-        plugins.fs.close(fd, (err) => {
+      plugins.fs.read(
+        fd,
+        buffer,
+        0,
+        chunkSize,
+        this.lastReadSize,
+        (err, bytesRead, buffer) => {
           if (err) {
             this.emit('error', err);
+            return;
           }
-        });
-      });
+
+          if (bytesRead > 0) {
+            this.lastReadSize += bytesRead;
+            this.push(buffer.slice(0, bytesRead)); // Push the data onto the stream
+          } else {
+            this.reading = false; // No more data to read for now
+            this.resetEndTimeout();
+          }
+
+          plugins.fs.close(fd, (err) => {
+            if (err) {
+              this.emit('error', err);
+            }
+          });
+        },
+      );
     });
   }
 
@@ -192,4 +212,4 @@ export class SmartReadStream extends plugins.stream.Readable {
     this.cleanup();
     callback(error);
   }
-}
+}

ts/memory.ts

@@ -27,7 +27,7 @@ export interface IToFsOptions {
 export let toFs = async (
   fileContentArg: string | Buffer | SmartFile | StreamFile,
   filePathArg: string,
-  optionsArg: IToFsOptions = {}
+  optionsArg: IToFsOptions = {},
 ) => {
   const done = plugins.smartpromise.defer();
 
@@ -57,7 +57,12 @@ export let toFs = async (
     throw new Error('fileContent is neither string nor Smartfile');
   }
   await smartfileFs.ensureDir(plugins.path.parse(filePath).dir);
-  plugins.fsExtra.writeFile(filePath, fileContent, { encoding: fileEncoding }, done.resolve);
+  plugins.fsExtra.writeFile(
+    filePath,
+    fileContent,
+    { encoding: fileEncoding },
+    done.resolve,
+  );
   return await done.promise;
 };
 
@@ -84,7 +89,10 @@ export const toFsSync = (fileArg: string, filePathArg: string) => {
   plugins.fsExtra.writeFileSync(filePath, fileString, { encoding: 'utf8' });
 };
 
-export let smartfileArrayToFs = async (smartfileArrayArg: SmartFile[], dirArg: string) => {
+export let smartfileArrayToFs = async (
+  smartfileArrayArg: SmartFile[],
+  dirArg: string,
+) => {
   await smartfileFs.ensureDir(dirArg);
   for (const smartfile of smartfileArrayArg) {
     await toFs(smartfile, dirArg, {

ts/plugins.ts

@@ -1,9 +1,10 @@
 // node native scope
 import * as fs from 'fs';
+import * as fsPromises from 'fs/promises';
 import * as path from 'path';
 import * as stream from 'stream';
 
-export { fs, path, stream };
+export { fs, fsPromises, path, stream };
 
 // @pushrocks scope
 import * as lik from '@push.rocks/lik';

tsconfig.json

@@ -6,9 +6,9 @@
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "esModuleInterop": true,
-    "verbatimModuleSyntax": true
+    "verbatimModuleSyntax": true,
+    "baseUrl": ".",
+    "paths": {}
   },
-  "exclude": [
-    "dist_*/**/*.d.ts"
-  ]
+  "exclude": ["dist_*/**/*.d.ts"]
 }