1.4.0

.gitignore

@@ -1,6 +1,20 @@
 .nogit/
-node_modules/
+
+# artifacts
 coverage/
 public/
 pages/
+
+# installs
+node_modules/
+
+# caches
 .yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# custom

.gitlab-ci.yml

@@ -1,125 +0,0 @@
-# gitzone standard
-image: hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-  - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
-
-stages:
-- security
-- test
-- release
-- metadata
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-  - npmci git mirror
-  tags:
-  - docker
-  - notpriv
-
-snyk:
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install -g snyk
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# test stage
-# ====================
-
-testLTS:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install lts
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-    
-testSTABLE:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-
-release:
-  stage: release
-  script:
-  - npmci node install stable
-  - npmci npm publish
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  image: docker:stable
-  allow_failure: true
-  services:
-    - docker:stable-dind
-  script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SOURCE_CODE="$PWD"
-        --volume "$PWD":/code
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
-  tags:
-  - docker
-  - priv
-
-trigger:
-  stage: metadata
-  script:
-  - npmci trigger
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-pages:
-  image: hosttoday/ht-docker-node:npmci
-  stage: metadata
-  script:
-    - npmci command npm install -g typedoc typescript
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command typedoc --module "commonjs" --target "ES2016" --out public/ ts/
-  tags:
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-    - public
-  allow_failure: true

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

changelog.md

@@ -0,0 +1,194 @@
+# Changelog
+
+## 2025-05-15 - 1.4.0 - feat(logging)
+Display failed test console logs in default mode
+
+- Introduce log buffering in TsTestLogger to capture console output for failed tests
+- Enhance TapParser to collect and display error details when tests fail
+- Update README and project plan to document log improvements for debugging
+
+## 2025-05-15 - 1.3.1 - fix(settings)
+Add local permissions configuration and remove obsolete test output log
+
+- Added .claude/settings.local.json to configure allowed permissions for web fetch and bash commands
+- Removed test-output.log to eliminate accidental commit of test artifacts
+
+## 2025-05-15 - 1.3.0 - feat(logger)
+Improve logging output and add --logfile support for persistent logs
+
+- Add new .claude/settings.local.json with logging permissions configuration
+- Remove obsolete readme.plan.md
+- Introduce test/test.console.ts to capture and display console outputs during tests
+- Update CLI in ts/index.ts to replace '--log-file' with '--logfile' flag
+- Enhance TsTestLogger to support file logging, clean ANSI sequences, and improved JSON output
+- Forward TAP protocol logs to testConsoleOutput in TapParser for better console distinction
+
+## 2025-05-15 - 1.2.0 - feat(logging)
+Improve logging output, CLI option parsing, and test report formatting.
+
+- Added a centralized TsTestLogger with support for multiple verbosity levels, JSON output, and file logging (TODO).
+- Integrated new logger into CLI parsing, TapParser, TapCombinator, and TsTest classes to ensure consistent and structured output.
+- Introduced new CLI options (--quiet, --verbose, --no-color, --json, --log-file) for enhanced user control.
+- Enhanced visual design with progress indicators, detailed error aggregation, and performance summaries.
+- Updated documentation and logging code to align with improved CI/CD behavior, including skipping non-CI tests.
+
+## 2025-05-15 - 1.1.0 - feat(cli)
+Enhance test discovery with support for single file and glob pattern execution using improved CLI argument detection
+
+- Detect execution mode (file, glob, directory) based on CLI input in ts/index.ts
+- Refactor TestDirectory to load test files using SmartFile for single file and glob patterns
+- Update TsTest to pass execution mode and adjust test discovery accordingly
+- Bump dependency versions for typedserver, tsbundle, tapbundle, and others
+- Add .claude/settings.local.json for updated permissions configuration
+
+## 2025-01-23 - 1.0.96 - fix(TsTest)
+Fixed improper type-check for promise-like testModule defaults
+
+- Corrected the type-check for promise-like default exports in test modules
+- Removed unnecessary setTimeout used for async execution
+
+## 2025-01-23 - 1.0.95 - fix(core)
+Fix delay handling in Chrome test execution
+
+- Replaced smartdelay.delayFor with native Promise-based delay mechanism in runInChrome method.
+
+## 2025-01-23 - 1.0.94 - fix(TsTest)
+Fix test module execution by ensuring promise resolution delay
+
+- Added a delay to ensure promise resolution when dynamically importing test modules in the runInChrome method.
+
+## 2025-01-23 - 1.0.93 - fix(tstest)
+Handle globalThis.tapPromise in browser runtime evaluation
+
+- Added support for using globalThis.tapPromise in the browser evaluation logic.
+- Added log messages to indicate the usage of globalThis.tapPromise.
+
+## 2025-01-23 - 1.0.92 - fix(core)
+Improve error logging for test modules without default promise
+
+- Added logging to display the exported test module content when it does not export a default promise.
+
+## 2025-01-23 - 1.0.91 - fix(core)
+Refactored tstest class to enhance promise handling for test modules.
+
+- Removed .gitlab-ci.yml configuration file.
+- Updated package.json dependency versions.
+- Added a condition to handle promiselike objects in tests.
+
+## 2024-04-18 - 1.0.89 to 1.0.90 - Enhancements and Bug Fixes
+Multiple updates and fixes have been made.
+
+- Updated core components to enhance stability and performance.
+
+## 2024-03-07 - 1.0.86 to 1.0.88 - Core Updates
+Continued improvements and updates in the core module.
+
+- Applied critical fixes to enhance core stability.
+
+## 2024-01-19 - 1.0.85 to 1.0.89 - Bug Fixes
+Series of core updates have been implemented.
+
+- Addressed known bugs and improved overall system functionality.
+
+## 2023-11-09 - 1.0.81 to 1.0.84 - Maintenance Updates
+Maintenance updates focusing on core reliability.
+
+- Improved core module through systematic updates.
+- Strengthened system robustness.
+
+## 2023-08-26 - 1.0.77 to 1.0.80 - Critical Fixes
+Critical fixes implemented in core functionality.
+
+- Enhanced core processing to fix existing issues.
+
+## 2023-07-13 - 1.0.75 to 1.0.76 - Stability Improvements
+Stability enhancements and minor improvements.
+
+- Focused on ensuring a stable operational core.
+
+## 2022-11-08 - 1.0.73 to 1.0.74 - Routine Fixes
+Routine core fixes to address reported issues.
+
+- Addressed minor issues in the core module.
+
+## 2022-08-03 - 1.0.71 to 1.0.72 - Core Enhancements
+Enhancements applied to core systems.
+
+- Tweaked core components for enhanced reliability.
+
+## 2022-05-04 - 1.0.69 to 1.0.70 - System Reliability Fixes
+Fixes targeting the reliability of the core systems.
+
+- Improved system reliability through targeted core updates.
+
+## 2022-03-17 - 1.0.65 to 1.0.68 - Major Core Updates
+Major updates and bug fixes delivered for core components.
+
+- Enhanced central operations through key updates.
+
+## 2022-02-15 - 1.0.60 to 1.0.64 - Core Stability Improvements
+Focused updates on core stability and performance.
+
+- Reinforced stability through systematic core changes.
+
+## 2021-11-07 - 1.0.54 to 1.0.59 - Core Fixes and Improvements
+Multiple core updates aimed at fixing and improving the system.
+
+- Addressed outstanding bugs and improved performance in the core.
+
+## 2021-08-20 - 1.0.50 to 1.0.53 - Core Functionality Updates
+Continued updates to improve core functionality and user experience.
+
+- Implemented essential core fixes to enhance user experience.
+
+## 2020-10-01 - 1.0.44 to 1.0.49 - Core System Enhancements
+Critical enhancements to core systems.
+
+- Improved core operations and tackled existing issues.
+
+## 2020-09-29 - 1.0.40 to 1.0.43 - Essential Fixes
+Series of essential fixes for the core system.
+
+- Rectified known issues and bolstered core functionalities.
+
+## 2020-07-10 - 1.0.35 to 1.0.39 - Core Function Fixes
+Focused improvements and fixes for critical components.
+
+- Addressed critical core functions to boost system performance.
+
+## 2020-06-01 - 1.0.31 to 1.0.34 - Core Updates
+Updates to maintain core functionality efficacy.
+
+- Fixed inefficiencies and updated essential components.
+
+## 2019-10-02 - 1.0.26 to 1.0.29 - Core Maintenance
+Regular maintenance and updates for core reliability.
+
+- Addressed multiple core issues and enhanced system stability.
+
+## 2019-05-28 - 1.0.20 to 1.0.25 - Core Improvements
+General improvements targeting core functionalities.
+
+- Made systematic improvements to core processes.
+
+## 2019-04-08 - 1.0.16 to 1.0.19 - Bug Squashing
+Resolved numerous issues within core operations.
+
+- Fixed and optimized core functionalities for better performance.
+  
+## 2018-12-06 - 1.0.15 - Dependency Updates
+Updates aimed at improving dependency management.
+
+- Ensured dependencies are up-to-date for optimal performance.
+  
+## 2018-08-14 - 1.0.14 - Test Improvement
+Major improvements in testing mechanisms and logging.
+
+- Improved test results handling for accuracy and reliability.
+- Enhanced logging features for increased clarity.
+  
+## 2018-08-04 - 1.0.1 to 1.0.13 - Initial Implementation and Fixes
+Initial release and critical updates focusing on core stability and functionality.
+
+- Implemented core components and established initial system structure.
+- Addressed key bugs and enhanced initial functionality.

cli.child.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+import * as cliTool from './ts/index.js';
+cliTool.runCli();

cli.js

@@ -1,3 +1,4 @@
 #!/usr/bin/env node
 process.env.CLI_CALL = 'true';
-require('./dist/index');
+const cliTool = await import('./dist_ts/index.js');
+cliTool.runCli();

cli.ts.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
 process.env.CLI_CALL = 'true';
-require('@gitzone/tsrun');
-require('./ts/index');
+
+import * as tsrun from '@git.zone/tsrun';
+tsrun.runPath('./cli.child.js', import.meta.url);

contribute.md

@@ -1,3 +0,0 @@
-# How to contribute
-
-Start with `tstest.classes.tstest.ts` to understand whats happening

npmextra.json

@@ -2,5 +2,16 @@
   "npmci": {
     "npmGlobalTools": [],
     "npmAccessLevel": "public"
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "gitzone",
+      "gitrepo": "tstest",
+      "description": "a test utility to run tests that match test/**/*.ts",
+      "npmPackagename": "@gitzone/tstest",
+      "license": "MIT"
+    }
   }
-}
+}

package.json

@@ -1,35 +1,58 @@
 {
-  "name": "@gitzone/tstest",
-  "version": "1.0.18",
+  "name": "@git.zone/tstest",
+  "version": "1.4.0",
   "private": false,
   "description": "a test utility to run tests that match test/**/*.ts",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "author": "Lossless GmbH",
   "license": "MIT",
   "bin": {
     "tstest": "./cli.js"
   },
   "scripts": {
-    "test": "(npm run prepareTest && npm run tstest && npm run cleanUp)",
+    "test": "(npm run cleanUp && npm run prepareTest && npm run tstest)",
     "prepareTest": "git clone https://gitlab.com/sandboxzone/sandbox-npmts.git .nogit/sandbox-npmts && cd .nogit/sandbox-npmts && npm install",
-    "tstest": "cd .nogit/sandbox-npmts && node ../../cli.ts.js test/",
+    "tstest": "cd .nogit/sandbox-npmts && node ../../cli.ts.js test/ --web",
     "cleanUp": "rm -rf .nogit/sandbox-npmts",
-    "format": "(gitzone format)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild --web --allowimplicitany  --skiplibcheck)",
+    "buildDocs": "tsdoc"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.3",
-    "@pushrocks/tapbundle": "^3.0.7"
+    "@git.zone/tsbuild": "^2.5.1",
+    "@types/node": "^22.15.18"
   },
   "dependencies": {
-    "@gitzone/tsrun": "^1.1.17",
-    "@pushrocks/consolecolor": "^2.0.1",
-    "@pushrocks/smartfile": "^6.0.11",
-    "@pushrocks/smartlog": "^2.0.9",
-    "@pushrocks/smartpromise": "^2.0.5",
-    "@pushrocks/smartshell": "^2.0.11",
-    "@types/figures": "^2.0.0",
-    "figures": "^2.0.0"
-  }
+    "@api.global/typedserver": "^3.0.74",
+    "@git.zone/tsbundle": "^2.2.5",
+    "@git.zone/tsrun": "^1.3.3",
+    "@push.rocks/consolecolor": "^2.0.2",
+    "@push.rocks/smartbrowser": "^2.0.8",
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartfile": "^11.2.0",
+    "@push.rocks/smartlog": "^3.0.9",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartshell": "^3.2.3",
+    "@push.rocks/tapbundle": "^6.0.3",
+    "@types/ws": "^8.18.1",
+    "figures": "^6.1.0",
+    "ws": "^8.18.2"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ],
+  "packageManager": "pnpm@10.10.0+sha512.d615db246fe70f25dcfea6d8d73dee782ce23e2245e3c4f6f888249fb568149318637dca73c2c5c8ef2a4ca0d5657fb9567188bfab47f566d1ee6ce987815c39"
 }

readme.md

@@ -0,0 +1,204 @@
+# @gitzone/tstest
+🧪 **A powerful, modern test runner for TypeScript** - making your test runs beautiful and informative!
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@gitzone/tstest)
+* [code.foss.global (source)](https://code.foss.global/gitzone/tstest)
+
+## Why tstest?
+
+**tstest** is a TypeScript test runner that makes testing delightful. It's designed for modern development workflows with beautiful output, flexible test execution, and powerful features that make debugging a breeze.
+
+### ✨ Key Features
+
+- 🎯 **Smart Test Execution** - Run all tests, single files, or use glob patterns
+- 🎨 **Beautiful Output** - Color-coded results with emojis and clean formatting
+- 📊 **Multiple Output Modes** - Choose from normal, quiet, verbose, or JSON output
+- 🔍 **Automatic Discovery** - Finds all your test files automatically
+- 🌐 **Cross-Environment** - Supports Node.js and browser testing
+- 📝 **Detailed Logging** - Optional file logging for debugging
+- ⚡ **Performance Metrics** - See which tests are slow
+- 🤖 **CI/CD Ready** - JSON output mode for automation
+
+## Installation
+
+```bash
+npm install --save-dev @gitzone/tstest
+# or with pnpm
+pnpm add -D @gitzone/tstest
+```
+
+## Usage
+
+### Basic Test Execution
+
+```bash
+# Run all tests in a directory
+tstest test/
+
+# Run a specific test file
+tstest test/test.mycomponent.ts
+
+# Use glob patterns
+tstest "test/**/*.spec.ts"
+tstest "test/unit/*.ts"
+```
+
+### Execution Modes
+
+**tstest** intelligently detects how you want to run your tests:
+
+1. **Directory mode** - Recursively finds all test files
+2. **File mode** - Runs a single test file
+3. **Glob mode** - Uses pattern matching for flexible test selection
+
+### Command Line Options
+
+| Option | Description |
+|--------|-------------|
+| `--quiet`, `-q` | Minimal output - perfect for CI environments |
+| `--verbose`, `-v` | Show all console output from tests |
+| `--no-color` | Disable colored output |
+| `--json` | Output results as JSON |
+| `--logfile` | Save detailed logs to `.nogit/testlogs/[testname].log` |
+
+### Example Outputs
+
+#### Normal Output (Default)
+```
+🔍 Test Discovery
+   Mode: directory
+   Pattern: test
+   Found: 4 test file(s)
+
+▶️  test/test.ts (1/4)
+   Runtime: node.js
+   ✅ prepare test (1ms)
+   Summary: 1/1 PASSED
+
+📊 Test Summary
+┌────────────────────────────────┐
+│ Total Files:                 4 │
+│ Total Tests:                 4 │
+│ Passed:                      4 │
+│ Failed:                      0 │
+│ Duration:                542ms │
+└────────────────────────────────┘
+
+ALL TESTS PASSED! 🎉
+```
+
+#### Quiet Mode
+```
+Found 4 tests
+✅ test functionality works
+✅ api calls return expected data
+✅ error handling works correctly
+✅ performance is within limits
+
+Summary: 4/4 | 542ms | PASSED
+```
+
+#### Verbose Mode
+Shows all console output from your tests, making debugging easier:
+```
+▶️  test/api.test.ts (1/1)
+   Runtime: node.js
+   Making API call to /users...
+   Response received: 200 OK
+   Processing user data...
+   ✅ api calls return expected data (145ms)
+   Summary: 1/1 PASSED
+```
+
+#### JSON Mode
+Perfect for CI/CD pipelines:
+```json
+{"event":"discovery","count":4,"pattern":"test","executionMode":"directory"}
+{"event":"fileStart","filename":"test/test.ts","runtime":"node.js","index":1,"total":4}
+{"event":"testResult","testName":"prepare test","passed":true,"duration":1}
+{"event":"summary","summary":{"totalFiles":4,"totalTests":4,"totalPassed":4,"totalFailed":0,"totalDuration":542}}
+```
+
+## Test File Naming Conventions
+
+tstest supports different test environments through file naming:
+
+| Pattern | Environment | Example |
+|---------|-------------|---------|
+| `*.ts` | Node.js (default) | `test.basic.ts` |
+| `*.node.ts` | Node.js only | `test.api.node.ts` |
+| `*.chrome.ts` | Chrome browser | `test.dom.chrome.ts` |
+| `*.browser.ts` | Browser environment | `test.ui.browser.ts` |
+| `*.both.ts` | Both Node.js and browser | `test.isomorphic.both.ts` |
+
+### Writing Tests
+
+tstest uses TAP (Test Anything Protocol) for test output. Use `@pushrocks/tapbundle` for the best experience:
+
+```typescript
+import { expect, tap } from '@push.rocks/tapbundle';
+
+tap.test('my awesome test', async () => {
+  const result = await myFunction();
+  expect(result).toEqual('expected value');
+});
+
+tap.start();
+```
+
+## Advanced Features
+
+### Glob Pattern Support
+
+Run specific test patterns:
+```bash
+# Run all unit tests
+tstest "test/unit/**/*.ts"
+
+# Run all integration tests
+tstest "test/integration/*.test.ts"
+
+# Run multiple patterns
+tstest "test/**/*.spec.ts" "test/**/*.test.ts"
+```
+
+### Automatic Logging
+
+Use `--logfile` to automatically save test output:
+```bash
+tstest test/ --logfile
+```
+
+This creates detailed logs in `.nogit/testlogs/[testname].log` for each test file.
+
+### Performance Analysis
+
+In verbose mode, see performance metrics:
+```
+⏱️  Performance Metrics:
+   Average per test: 135ms
+   Slowest test: api integration test (486ms)
+```
+
+### CI/CD Integration
+
+For continuous integration, combine quiet and JSON modes:
+```bash
+# GitHub Actions example
+tstest test/ --json > test-results.json
+
+# Or minimal output
+tstest test/ --quiet
+```
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+## License
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

readme.plan.md

@@ -0,0 +1,41 @@
+# Plan for showing logs for failed tests
+
+!! FIRST: Reread /home/philkunz/.claude/CLAUDE.md to ensure following all guidelines !!
+
+## Goal
+When a test fails, we want to display all the console logs from that failed test in the terminal, even without the --verbose flag. This makes debugging failed tests much easier.
+
+## Current Behavior
+- Default mode: Only shows test results, no console logs
+- Verbose mode: Shows all console logs from all tests
+- When a test fails: Only shows the error message
+
+## Desired Behavior
+- Default mode: Shows test results, and IF a test fails, shows all console logs from that failed test
+- Verbose mode: Shows all console logs from all tests (unchanged)
+- When a test fails: Shows all console logs from that test plus the error
+
+## Implementation Plan
+
+### 1. Update TapParser
+- Store console logs for each test temporarily
+- When a test fails, mark that its logs should be shown
+
+### 2. Update TsTestLogger
+- Add a new method to handle failed test logs
+- Modify testConsoleOutput to buffer logs when not in verbose mode
+- When a test fails, flush the buffered logs for that test
+
+### 3. Update test result handling
+- When a test fails, trigger display of all buffered logs for that test
+- Clear logs after each test completes successfully
+
+## Code Changes Needed
+1. Add log buffering to TapParser
+2. Update TsTestLogger to handle failed test logs
+3. Modify test result processing to show logs on failure
+
+## Files to Modify
+- `ts/tstest.classes.tap.parser.ts` - Add log buffering
+- `ts/tstest.logging.ts` - Add failed test log handling
+- `ts/tstest.classes.tap.testresult.ts` - May need to store logs

test/subdir/test.sub.ts

@@ -0,0 +1,8 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+
+tap.test('subdirectory test execution', async () => {
+  console.log('This test verifies subdirectory test discovery works');
+  expect(true).toBeTrue();
+});
+
+tap.start();

test/test.console.ts

@@ -0,0 +1,11 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+
+tap.test('Test with console output', async () => {
+  console.log('Log message 1 from test');
+  console.log('Log message 2 from test');
+  console.error('Error message from test');
+  console.warn('Warning message from test');
+  expect(true).toBeTrue();
+});
+
+tap.start();

test/test.fail.ts

@@ -0,0 +1,13 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+
+tap.test('This test should fail', async () => {
+  console.log('This test will fail on purpose');
+  expect(true).toBeFalse();
+});
+
+tap.test('This test should pass', async () => {
+  console.log('This test will pass');
+  expect(true).toBeTrue();
+});
+
+tap.start();

test/test.failing-with-logs.ts

@@ -0,0 +1,23 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+
+tap.test('Test that will fail with console logs', async () => {
+  console.log('Starting the test...');
+  console.log('Doing some setup work');
+  console.log('About to check assertion');
+  
+  const value = 42;
+  console.log(`The value is: ${value}`);
+  
+  // This will fail
+  expect(value).toEqual(100);
+  
+  console.log('This log will not be reached');
+});
+
+tap.test('Test that passes', async () => {
+  console.log('This test passes');
+  console.log('So these logs should not show in default mode');
+  expect(true).toBeTrue();
+});
+
+tap.start();

test/test.glob.ts

@@ -0,0 +1,8 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+
+tap.test('glob pattern test execution', async () => {
+  console.log('This test verifies glob pattern execution works');
+  expect(true).toBeTrue();
+});
+
+tap.start();

test/test.single.ts

@@ -0,0 +1,8 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+
+tap.test('single file test execution', async () => {
+  console.log('This test verifies single file execution works');
+  expect(true).toBeTrue();
+});
+
+tap.start();

test/test.ts

@@ -1,5 +1,5 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import * as tstest from '../ts/index';
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as tstest from '../ts/index.js';
 
 tap.test('prepare test', async () => {});
 

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@git.zone/tstest',
+  version: '1.4.0',
+  description: 'a test utility to run tests that match test/**/*.ts'
+}

ts/index.ts

@@ -1,9 +1,71 @@
-import { TsTest } from './tstest.classes.tstest';
+import { TsTest } from './tstest.classes.tstest.js';
+import type { LogOptions } from './tstest.logging.js';
 
-const cliRun = async () => {
-  if (process.env.CLI_CALL) {
-    const tsTestInstance = new TsTest(process.cwd(), process.argv[2]);
-    await tsTestInstance.run();
+export enum TestExecutionMode {
+  DIRECTORY = 'directory',
+  FILE = 'file',
+  GLOB = 'glob'
+}
+
+export const runCli = async () => {
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  const logOptions: LogOptions = {};
+  let testPath: string | null = null;
+  
+  // Parse options
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    switch (arg) {
+      case '--quiet':
+      case '-q':
+        logOptions.quiet = true;
+        break;
+      case '--verbose':
+      case '-v':
+        logOptions.verbose = true;
+        break;
+      case '--no-color':
+        logOptions.noColor = true;
+        break;
+      case '--json':
+        logOptions.json = true;
+        break;
+      case '--log-file':
+      case '--logfile':
+        logOptions.logFile = true; // Set this as a flag, not a value
+        break;
+      default:
+        if (!arg.startsWith('-')) {
+          testPath = arg;
+        }
+    }
   }
+  
+  if (!testPath) {
+    console.error('You must specify a test directory/file/pattern as argument. Please try again.');
+    console.error('\nUsage: tstest <path> [options]');
+    console.error('\nOptions:');
+    console.error('  --quiet, -q     Minimal output');
+    console.error('  --verbose, -v   Verbose output');
+    console.error('  --no-color      Disable colored output');
+    console.error('  --json          Output results as JSON');
+    console.error('  --logfile       Write logs to .nogit/testlogs/[testfile].log');
+    process.exit(1);
+  }
+  
+  let executionMode: TestExecutionMode;
+  
+  // Detect execution mode based on the argument
+  if (testPath.includes('*') || testPath.includes('?') || testPath.includes('[') || testPath.includes('{')) {
+    executionMode = TestExecutionMode.GLOB;
+  } else if (testPath.endsWith('.ts')) {
+    executionMode = TestExecutionMode.FILE;
+  } else {
+    executionMode = TestExecutionMode.DIRECTORY;
+  }
+  
+  const tsTestInstance = new TsTest(process.cwd(), testPath, executionMode, logOptions);
+  await tsTestInstance.run();
 };
-cliRun();

ts/tstest.classes.tap.combinator.ts

@@ -1,47 +1,42 @@
 // ============
 // combines different tap test files to an overall result
 // ============
-import * as plugins from './tstest.plugins';
-import { coloredString as cs } from '@pushrocks/consolecolor';
+import * as plugins from './tstest.plugins.js';
+import { coloredString as cs } from '@push.rocks/consolecolor';
 
-import { TapParser } from './tstest.classes.tap.parser';
-import * as logPrefixes from './tstest.logprefixes';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import * as logPrefixes from './tstest.logprefixes.js';
+import { TsTestLogger } from './tstest.logging.js';
 
 export class TapCombinator {
   tapParserStore: TapParser[] = [];
+  private logger: TsTestLogger;
+  
+  constructor(logger: TsTestLogger) {
+    this.logger = logger;
+  }
+  
   addTapParser(tapParserArg: TapParser) {
     this.tapParserStore.push(tapParserArg);
   }
 
   evaluate() {
-    console.log(
-      `${logPrefixes.TsTestPrefix} RESULTS FOR ${this.tapParserStore.length} TESTFILE(S):`
-    );
-
-    let failGlobal = false; // determine wether tstest should fail
+    // Call the logger's summary method
+    this.logger.summary();
+    
+    // Check for failures
+    let failGlobal = false;
     for (const tapParser of this.tapParserStore) {
-      if (tapParser.getErrorTests().length === 0) {
-        let overviewString =
-          logPrefixes.TsTestPrefix +
-          cs(` ${tapParser.fileName} ${plugins.figures.tick}`, 'green') +
-          ` ${plugins.figures.pointer} ` +
-          tapParser.getTestOverviewAsString();
-        console.log(overviewString);
-      } else {
-        let overviewString =
-          logPrefixes.TsTestPrefix +
-          cs(` ${tapParser.fileName} ${plugins.figures.cross}`, 'red') +
-          ` ${plugins.figures.pointer} ` +
-          tapParser.getTestOverviewAsString();
-        console.log(overviewString);
+      if (!tapParser.expectedTests || 
+          tapParser.expectedTests !== tapParser.receivedTests || 
+          tapParser.getErrorTests().length > 0) {
         failGlobal = true;
+        break;
       }
     }
-    console.log(cs(plugins.figures.hamburger.repeat(48), 'cyan'));
-    if (!failGlobal) {
-      console.log(cs('FINAL RESULT: SUCCESS!', 'green'));
-    } else {
-      console.log(cs('FINAL RESULT: FAIL!', 'red'));
+    
+    // Exit with error code if tests failed
+    if (failGlobal) {
       process.exit(1);
     }
   }

ts/tstest.classes.tap.parser.ts

@@ -1,12 +1,13 @@
 import { ChildProcess } from 'child_process';
-import { coloredString as cs } from '@pushrocks/consolecolor';
+import { coloredString as cs } from '@push.rocks/consolecolor';
 
 // ============
 // combines different tap test files to an overall result
 // ============
-import * as plugins from './tstest.plugins';
-import { TapTestResult } from './tstest.classes.tap.testresult';
-import * as logPrefixes from './tstest.logprefixes';
+import * as plugins from './tstest.plugins.js';
+import { TapTestResult } from './tstest.classes.tap.testresult.js';
+import * as logPrefixes from './tstest.logprefixes.js';
+import { TsTestLogger } from './tstest.logging.js';
 
 export class TapParser {
   testStore: TapTestResult[] = [];
@@ -17,11 +18,19 @@ export class TapParser {
 
   testStatusRegex = /(ok|not\sok)\s([0-9]+)\s-\s(.*)\s#\stime=(.*)ms$/;
   activeTapTestResult: TapTestResult;
+  collectingErrorDetails: boolean = false;
+  currentTestError: string[] = [];
+
+  pretaskRegex = /^::__PRETASK:(.*)$/;
+  
+  private logger: TsTestLogger;
 
   /**
    * the constructor for TapParser
    */
-  constructor(public fileName: string) {}
+  constructor(public fileName: string, logger?: TsTestLogger) {
+    this.logger = logger;
+  }
 
   private _getNewTapTestResult() {
     this.activeTapTestResult = new TapTestResult(this.testStore.length + 1);
@@ -43,12 +52,20 @@ export class TapParser {
         logLineIsTapProtocol = true;
         const regexResult = this.expectedTestsRegex.exec(logLine);
         this.expectedTests = parseInt(regexResult[2]);
-        console.log(
-          `${logPrefixes.TapPrefix} ${cs(`Expecting ${this.expectedTests} tests!`, 'blue')}`
-        );
+        if (this.logger) {
+          this.logger.tapOutput(`Expecting ${this.expectedTests} tests!`);
+        }
 
         // initiating first TapResult
         this._getNewTapTestResult();
+      } else if (this.pretaskRegex.test(logLine)) {
+        logLineIsTapProtocol = true;
+        const pretaskContentMatch = this.pretaskRegex.exec(logLine);
+        if (pretaskContentMatch && pretaskContentMatch[1]) {
+          if (this.logger) {
+            this.logger.tapOutput(`Pretask -> ${pretaskContentMatch[1]}: Success.`);
+          }
+        }
       } else if (this.testStatusRegex.test(logLine)) {
         logLineIsTapProtocol = true;
         const regexResult = this.testStatusRegex.exec(logLine);
@@ -65,26 +82,23 @@ export class TapParser {
 
         // test for protocol error
         if (testId !== this.activeTapTestResult.id) {
-          console.log(
-            `${logPrefixes.TapErrorPrefix} Something is strange! Test Ids are not equal!`
-          );
+          if (this.logger) {
+            this.logger.error('Something is strange! Test Ids are not equal!');
+          }
         }
         this.activeTapTestResult.setTestResult(testOk);
 
         if (testOk) {
-          console.log(
-            logPrefixes.TapPrefix,
-            `${cs(`T${testId} ${plugins.figures.tick}`, 'green')} ${plugins.figures.arrowRight} ` +
-              cs(testSubject, 'blue') +
-              ` | ${cs(`${testDuration} ms`, 'orange')}`
-          );
+          if (this.logger) {
+            this.logger.testResult(testSubject, true, testDuration);
+          }
         } else {
-          console.log(
-            logPrefixes.TapPrefix,
-            `${cs(`T${testId} ${plugins.figures.cross}`, 'red')} ${plugins.figures.arrowRight} ` +
-              cs(testSubject, 'blue') +
-              ` | ${cs(`${testDuration} ms`, 'orange')}`
-          );
+          // Start collecting error details for failed test
+          this.collectingErrorDetails = true;
+          this.currentTestError = [];
+          if (this.logger) {
+            this.logger.testResult(testSubject, false, testDuration);
+          }
         }
       }
 
@@ -92,10 +106,43 @@ export class TapParser {
         if (this.activeTapTestResult) {
           this.activeTapTestResult.addLogLine(logLine);
         }
-        console.log(logLine);
+        
+        // Check if we're collecting error details
+        if (this.collectingErrorDetails) {
+          // Check if this line is an error detail (starts with Error: or has stack trace characteristics)
+          if (logLine.trim().startsWith('Error:') || logLine.trim().match(/^\s*at\s/)) {
+            this.currentTestError.push(logLine);
+          } else if (this.currentTestError.length > 0) {
+            // End of error details, show the error
+            const errorMessage = this.currentTestError.join('\n');
+            if (this.logger) {
+              this.logger.testErrorDetails(errorMessage);
+            }
+            this.collectingErrorDetails = false;
+            this.currentTestError = [];
+          }
+        }
+        
+        // Don't output TAP error details as console output when we're collecting them
+        if (!this.collectingErrorDetails || (!logLine.trim().startsWith('Error:') && !logLine.trim().match(/^\s*at\s/))) {
+          if (this.logger) {
+            // This is console output from the test file, not TAP protocol
+            this.logger.testConsoleOutput(logLine);
+          }
+        }
       }
 
       if (this.activeTapTestResult && this.activeTapTestResult.testSettled) {
+        // Ensure any pending error is shown before settling the test
+        if (this.collectingErrorDetails && this.currentTestError.length > 0) {
+          const errorMessage = this.currentTestError.join('\n');
+          if (this.logger) {
+            this.logger.testErrorDetails(errorMessage);
+          }
+          this.collectingErrorDetails = false;
+          this.currentTestError = [];
+        }
+        
         this.testStore.push(this.activeTapTestResult);
         this._getNewTapTestResult();
       }
@@ -105,15 +152,15 @@ export class TapParser {
   /**
    * returns all tests that are not completed
    */
-  getUncompletedTests() {
+  public getUncompletedTests() {
     // TODO:
   }
 
   /**
    * returns all tests that threw an error
    */
-  getErrorTests() {
-    return this.testStore.filter(tapTestArg => {
+  public getErrorTests() {
+    return this.testStore.filter((tapTestArg) => {
       return !tapTestArg.testOk;
     });
   }
@@ -123,7 +170,7 @@ export class TapParser {
    */
   getTestOverviewAsString() {
     let overviewString = '';
-    for (let test of this.testStore) {
+    for (const test of this.testStore) {
       if (overviewString !== '') {
         overviewString += ' | ';
       }
@@ -140,45 +187,56 @@ export class TapParser {
    * handles a tap process
    * @param childProcessArg
    */
-  async handleTapProcess(childProcessArg: ChildProcess) {
+  public async handleTapProcess(childProcessArg: ChildProcess) {
     const done = plugins.smartpromise.defer();
-    childProcessArg.stdout.on('data', data => {
+    childProcessArg.stdout.on('data', (data) => {
       this._processLog(data);
     });
-    childProcessArg.stderr.on('data', data => {
+    childProcessArg.stderr.on('data', (data) => {
       this._processLog(data);
     });
-    childProcessArg.on('exit', () => {
-      this.receivedTests = this.testStore.length;
-
-      // check wether all tests ran
-      if (this.expectedTests === this.receivedTests) {
-        console.log(
-          `${logPrefixes.TapPrefix} ${cs(
-            `${this.receivedTests} out of ${this.expectedTests} Tests completed!`,
-            'green'
-          )}`
-        );
-      } else {
-        console.log(
-          `${logPrefixes.TapErrorPrefix} ${cs(
-            `Only ${this.receivedTests} out of ${this.expectedTests} completed!`,
-            'red'
-          )}`
-        );
-      }
-      if (this.getErrorTests().length === 0) {
-        console.log(`${logPrefixes.TapPrefix} ${cs(`All tests are successfull!!!`, 'green')}`);
-      } else {
-        console.log(
-          `${logPrefixes.TapPrefix} ${cs(
-            `${this.getErrorTests().length} tests threw an error!!!`,
-            'red'
-          )}`
-        );
-      }
+    childProcessArg.on('exit', async () => {
+      await this.evaluateFinalResult();
       done.resolve();
     });
     await done.promise;
   }
+
+  public async handleTapLog(tapLog: string) {
+    this._processLog(tapLog);
+  }
+
+  public async evaluateFinalResult() {
+    this.receivedTests = this.testStore.length;
+
+    // check wether all tests ran
+    if (this.expectedTests === this.receivedTests) {
+      if (this.logger) {
+        this.logger.tapOutput(`${this.receivedTests} out of ${this.expectedTests} Tests completed!`);
+      }
+    } else {
+      if (this.logger) {
+        this.logger.error(`Only ${this.receivedTests} out of ${this.expectedTests} completed!`);
+      }
+    }
+    if (!this.expectedTests) {
+      if (this.logger) {
+        this.logger.error('No tests were defined. Therefore the testfile failed!');
+      }
+    } else if (this.expectedTests !== this.receivedTests) {
+      if (this.logger) {
+        this.logger.error('The amount of received tests and expectedTests is unequal! Therefore the testfile failed');
+      }
+    } else if (this.getErrorTests().length === 0) {
+      if (this.logger) {
+        this.logger.tapOutput('All tests are successfull!!!');
+        this.logger.testFileEnd(this.receivedTests, 0, 0);
+      }
+    } else {
+      if (this.logger) {
+        this.logger.tapOutput(`${this.getErrorTests().length} tests threw an error!!!`, true);
+        this.logger.testFileEnd(this.receivedTests - this.getErrorTests().length, this.getErrorTests().length, 0);
+      }
+    }
+  }
 }

ts/tstest.classes.tap.testresult.ts

@@ -1,7 +1,7 @@
 // ============
 // combines different tap test files to an overall result
 // ============
-import * as plugins from './tstest.plugins';
+import * as plugins from './tstest.plugins.js';
 
 export class TapTestResult {
   testLogBuffer = Buffer.from('');

ts/tstest.classes.testdirectory.ts

@@ -1,11 +1,12 @@
-import * as plugins from './tstest.plugins';
-import * as paths from './tstest.paths';
-import { Smartfile } from '@pushrocks/smartfile';
+import * as plugins from './tstest.plugins.js';
+import * as paths from './tstest.paths.js';
+import { SmartFile } from '@push.rocks/smartfile';
+import { TestExecutionMode } from './index.js';
 
 // tap related stuff
-import { TapCombinator } from './tstest.classes.tap.combinator';
-import { TapParser } from './tstest.classes.tap.parser';
-import { TapTestResult } from './tstest.classes.tap.testresult';
+import { TapCombinator } from './tstest.classes.tap.combinator.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import { TapTestResult } from './tstest.classes.tap.testresult.js';
 
 export class TestDirectory {
   /**
@@ -14,43 +15,87 @@ export class TestDirectory {
   cwd: string;
 
   /**
-   * the relative location of the test dir
+   * the test path or pattern
    */
-  relativePath: string;
+  testPath: string;
 
   /**
-   * the absolute path of the test dir
+   * the execution mode
    */
-  absolutePath: string;
+  executionMode: TestExecutionMode;
 
   /**
    * an array of Smartfiles
    */
-  testfileArray: Smartfile[] = [];
+  testfileArray: SmartFile[] = [];
 
   /**
    * the constructor for TestDirectory
-   * tell it the path
-   * @param pathToTestDirectory
+   * @param cwdArg - the current working directory
+   * @param testPathArg - the test path/pattern
+   * @param executionModeArg - the execution mode
    */
-  constructor(cwdArg: string, relativePathToTestDirectory: string) {
+  constructor(cwdArg: string, testPathArg: string, executionModeArg: TestExecutionMode) {
     this.cwd = cwdArg;
-    this.relativePath = relativePathToTestDirectory;
+    this.testPath = testPathArg;
+    this.executionMode = executionModeArg;
   }
 
   private async _init() {
-    this.testfileArray = await plugins.smartfile.fs.fileTreeToObject(
-      plugins.path.join(this.cwd, this.relativePath),
-      '**/*.ts'
-    );
+    switch (this.executionMode) {
+      case TestExecutionMode.FILE:
+        // Single file mode
+        const filePath = plugins.path.isAbsolute(this.testPath) 
+          ? this.testPath 
+          : plugins.path.join(this.cwd, this.testPath);
+        
+        if (await plugins.smartfile.fs.fileExists(filePath)) {
+          this.testfileArray = [await plugins.smartfile.SmartFile.fromFilePath(filePath)];
+        } else {
+          throw new Error(`Test file not found: ${filePath}`);
+        }
+        break;
+        
+      case TestExecutionMode.GLOB:
+        // Glob pattern mode - use listFileTree which supports glob patterns
+        const globPattern = this.testPath;
+        const matchedFiles = await plugins.smartfile.fs.listFileTree(this.cwd, globPattern);
+        
+        this.testfileArray = await Promise.all(
+          matchedFiles.map(async (filePath) => {
+            const absolutePath = plugins.path.isAbsolute(filePath) 
+              ? filePath 
+              : plugins.path.join(this.cwd, filePath);
+            return await plugins.smartfile.SmartFile.fromFilePath(absolutePath);
+          })
+        );
+        break;
+        
+      case TestExecutionMode.DIRECTORY:
+        // Directory mode - now recursive with ** pattern
+        const dirPath = plugins.path.join(this.cwd, this.testPath);
+        const testPattern = '**/test*.ts';
+        
+        const testFiles = await plugins.smartfile.fs.listFileTree(dirPath, testPattern);
+        
+        this.testfileArray = await Promise.all(
+          testFiles.map(async (filePath) => {
+            const absolutePath = plugins.path.isAbsolute(filePath)
+              ? filePath
+              : plugins.path.join(dirPath, filePath);
+            return await plugins.smartfile.SmartFile.fromFilePath(absolutePath);
+          })
+        );
+        break;
+    }
   }
 
   async getTestFilePathArray() {
     await this._init();
     const testFilePaths: string[] = [];
     for (const testFile of this.testfileArray) {
-      const filePath = plugins.path.join(this.relativePath, testFile.path);
-      testFilePaths.push(filePath);
+      // Use the path directly from the SmartFile
+      testFilePaths.push(testFile.path);
     }
     return testFilePaths;
   }

ts/tstest.classes.tstest.ts

@@ -1,55 +1,218 @@
-import * as plugins from './tstest.plugins';
-import * as paths from './tstest.paths';
-import * as logPrefixes from './tstest.logprefixes';
+import * as plugins from './tstest.plugins.js';
+import * as paths from './tstest.paths.js';
+import * as logPrefixes from './tstest.logprefixes.js';
 
-import { coloredString as cs } from '@pushrocks/consolecolor';
+import { coloredString as cs } from '@push.rocks/consolecolor';
 
-import { TestDirectory } from './tstest.classes.testdirectory';
-import { TapCombinator } from './tstest.classes.tap.combinator';
-import { TapParser } from './tstest.classes.tap.parser';
+import { TestDirectory } from './tstest.classes.testdirectory.js';
+import { TapCombinator } from './tstest.classes.tap.combinator.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import { TestExecutionMode } from './index.js';
+import { TsTestLogger } from './tstest.logging.js';
+import type { LogOptions } from './tstest.logging.js';
 
 export class TsTest {
-  testDir: TestDirectory;
+  public testDir: TestDirectory;
+  public executionMode: TestExecutionMode;
+  public logger: TsTestLogger;
 
-  constructor(cwdArg: string, relativePathToTestDirectory: string) {
-    this.testDir = new TestDirectory(cwdArg, relativePathToTestDirectory);
+  public smartshellInstance = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+    pathDirectories: [paths.binDirectory],
+    sourceFilePaths: [],
+  });
+  public smartbrowserInstance = new plugins.smartbrowser.SmartBrowser();
+
+  public tsbundleInstance = new plugins.tsbundle.TsBundle();
+
+  constructor(cwdArg: string, testPathArg: string, executionModeArg: TestExecutionMode, logOptions: LogOptions = {}) {
+    this.executionMode = executionModeArg;
+    this.testDir = new TestDirectory(cwdArg, testPathArg, executionModeArg);
+    this.logger = new TsTestLogger(logOptions);
   }
 
   async run() {
     const fileNamesToRun: string[] = await this.testDir.getTestFilePathArray();
-    console.log(cs(plugins.figures.hamburger.repeat(80), 'cyan'));
-    console.log('');
-    console.log(`${logPrefixes.TsTestPrefix} FOUND ${fileNamesToRun.length} TESTFILE(S):`);
-    for (const fileName of fileNamesToRun) {
-      console.log(`${logPrefixes.TsTestPrefix} ${cs(fileName, 'orange')}`);
-    }
-    console.log('-'.repeat(48));
-    console.log(''); // force new line
-    const smartshellInstance = new plugins.smartshell.Smartshell({
-      executor: 'bash',
-      pathDirectories: [paths.binDirectory],
-      sourceFilePaths: []
-    });
-    const tapCombinator = new TapCombinator(); // lets create the TapCombinator
-    for (const fileName of fileNamesToRun) {
-      console.log(`${cs('=> ', 'blue')} Running ${cs(fileName, 'orange')}`);
-      console.log(cs(`=`.repeat(16), 'cyan'));
-      const tapParser = new TapParser(fileName);
+    
+    // Log test discovery
+    this.logger.testDiscovery(
+      fileNamesToRun.length, 
+      this.testDir.testPath,
+      this.executionMode
+    );
 
-      // tsrun options
-      let tsrunOptions = '';
-      if (process.argv.includes('--web')) {
-        tsrunOptions += ' --web';
+    const tapCombinator = new TapCombinator(this.logger); // lets create the TapCombinator
+    let fileIndex = 0;
+    for (const fileNameArg of fileNamesToRun) {
+      fileIndex++;
+      switch (true) {
+        case process.env.CI && fileNameArg.includes('.nonci.'):
+          this.logger.tapOutput(`Skipping ${fileNameArg} - marked as non-CI`);
+          break;
+        case fileNameArg.endsWith('.browser.ts') || fileNameArg.endsWith('.browser.nonci.ts'):
+          const tapParserBrowser = await this.runInChrome(fileNameArg, fileIndex, fileNamesToRun.length);
+          tapCombinator.addTapParser(tapParserBrowser);
+          break;
+        case fileNameArg.endsWith('.both.ts') || fileNameArg.endsWith('.both.nonci.ts'):
+          this.logger.sectionStart('Part 1: Chrome');
+          const tapParserBothBrowser = await this.runInChrome(fileNameArg, fileIndex, fileNamesToRun.length);
+          tapCombinator.addTapParser(tapParserBothBrowser);
+          this.logger.sectionEnd();
+          
+          this.logger.sectionStart('Part 2: Node');
+          const tapParserBothNode = await this.runInNode(fileNameArg, fileIndex, fileNamesToRun.length);
+          tapCombinator.addTapParser(tapParserBothNode);
+          this.logger.sectionEnd();
+          break;
+        default:
+          const tapParserNode = await this.runInNode(fileNameArg, fileIndex, fileNamesToRun.length);
+          tapCombinator.addTapParser(tapParserNode);
+          break;
       }
-
-      const execResultStreaming = await smartshellInstance.execStreamingSilent(
-        `tsrun ${fileName}${tsrunOptions}`
-      );
-      await tapParser.handleTapProcess(execResultStreaming.childProcess);
-      console.log(cs(`^`.repeat(16), 'cyan'));
-      console.log(''); // force new line
-      tapCombinator.addTapParser(tapParser);
     }
     tapCombinator.evaluate();
   }
+
+  public async runInNode(fileNameArg: string, index: number, total: number): Promise<TapParser> {
+    this.logger.testFileStart(fileNameArg, 'node.js', index, total);
+    const tapParser = new TapParser(fileNameArg + ':node', this.logger);
+
+    // tsrun options
+    let tsrunOptions = '';
+    if (process.argv.includes('--web')) {
+      tsrunOptions += ' --web';
+    }
+
+    const execResultStreaming = await this.smartshellInstance.execStreamingSilent(
+      `tsrun ${fileNameArg}${tsrunOptions}`
+    );
+    await tapParser.handleTapProcess(execResultStreaming.childProcess);
+    return tapParser;
+  }
+
+  public async runInChrome(fileNameArg: string, index: number, total: number): Promise<TapParser> {
+    this.logger.testFileStart(fileNameArg, 'chromium', index, total);
+
+    // lets get all our paths sorted
+    const tsbundleCacheDirPath = plugins.path.join(paths.cwd, './.nogit/tstest_cache');
+    const bundleFileName = fileNameArg.replace('/', '__') + '.js';
+    const bundleFilePath = plugins.path.join(tsbundleCacheDirPath, bundleFileName);
+
+    // lets bundle the test
+    await plugins.smartfile.fs.ensureEmptyDir(tsbundleCacheDirPath);
+    await this.tsbundleInstance.build(process.cwd(), fileNameArg, bundleFilePath, {
+      bundler: 'esbuild',
+    });
+
+    // lets create a server
+    const server = new plugins.typedserver.servertools.Server({
+      cors: true,
+      port: 3007,
+    });
+    server.addRoute(
+      '/test',
+      new plugins.typedserver.servertools.Handler('GET', async (req, res) => {
+        res.type('.html');
+        res.write(`
+        <html>
+          <head>
+            <script>
+              globalThis.testdom = true;
+            </script>
+          </head>
+          <body></body>
+        </html>
+      `);
+        res.end();
+      })
+    );
+    server.addRoute('*', new plugins.typedserver.servertools.HandlerStatic(tsbundleCacheDirPath));
+    await server.start();
+
+    // lets handle realtime comms
+    const tapParser = new TapParser(fileNameArg + ':chrome', this.logger);
+    const wss = new plugins.ws.WebSocketServer({ port: 8080 });
+    wss.on('connection', (ws) => {
+      ws.on('message', (message) => {
+        const messageStr = message.toString();
+        if (messageStr.startsWith('console:')) {
+          const [, level, ...messageParts] = messageStr.split(':');
+          this.logger.browserConsole(messageParts.join(':'), level);
+        } else {
+          tapParser.handleTapLog(messageStr);
+        }
+      });
+    });
+
+    // lets do the browser bit
+    await this.smartbrowserInstance.start();
+    const evaluation = await this.smartbrowserInstance.evaluateOnPage(
+      `http://localhost:3007/test?bundleName=${bundleFileName}`,
+      async () => {
+        // lets enable real time comms
+        const ws = new WebSocket('ws://localhost:8080');
+        await new Promise((resolve) => (ws.onopen = resolve));
+
+        // Ensure this function is declared with 'async'
+        const logStore = [];
+        const originalLog = console.log;
+        const originalError = console.error;
+
+        // Override console methods to capture the logs
+        console.log = (...args) => {
+          logStore.push(args.join(' '));
+          ws.send(args.join(' '));
+          originalLog(...args);
+        };
+        console.error = (...args) => {
+          logStore.push(args.join(' '));
+          ws.send(args.join(' '));
+          originalError(...args);
+        };
+
+        const bundleName = new URLSearchParams(window.location.search).get('bundleName');
+        originalLog(`::TSTEST IN CHROMIUM:: Relevant Script name is: ${bundleName}`);
+
+        try {
+          // Dynamically import the test module
+          const testModule = await import(`/${bundleName}`);
+          if (testModule && testModule.default && testModule.default instanceof Promise) {
+            // Execute the exported test function
+            await testModule.default;
+          } else if (testModule && testModule.default && typeof testModule.default.then === 'function') {
+            console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+            console.log('Test module default export is just promiselike: Something might be messing with your Promise implementation.');
+            console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+            await testModule.default;
+          } else if (globalThis.tapPromise && typeof globalThis.tapPromise.then === 'function') {
+            console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+            console.log('Using globalThis.tapPromise');
+            console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+            await testModule.default;
+          } else {
+            console.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+            console.error('Test module does not export a default promise.');
+            console.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+            console.log(`We got: ${JSON.stringify(testModule)}`);
+
+          }
+        } catch (err) {
+          console.error(err);
+        }
+
+        return logStore.join('\n');
+      }
+    );
+    await this.smartbrowserInstance.stop();
+    await server.stop();
+    wss.close();
+    console.log(
+      `${cs('=> ', 'blue')} Stopped ${cs(fileNameArg, 'orange')} chromium instance and server.`
+    );
+    // lets create the tap parser
+    await tapParser.evaluateFinalResult();
+    return tapParser;
+  }
+
+  public async runInDeno() {}
 }

ts/tstest.logging.ts

@@ -0,0 +1,399 @@
+import { coloredString as cs } from '@push.rocks/consolecolor';
+import * as plugins from './tstest.plugins.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface LogOptions {
+  quiet?: boolean;
+  verbose?: boolean;
+  noColor?: boolean;
+  json?: boolean;
+  logFile?: boolean;
+}
+
+export interface TestFileResult {
+  file: string;
+  passed: number;
+  failed: number;
+  total: number;
+  duration: number;
+  tests: Array<{
+    name: string;
+    passed: boolean;
+    duration: number;
+    error?: string;
+  }>;
+}
+
+export interface TestSummary {
+  totalFiles: number;
+  totalTests: number;
+  totalPassed: number;
+  totalFailed: number;
+  totalDuration: number;
+  fileResults: TestFileResult[];
+}
+
+export class TsTestLogger {
+  private options: LogOptions;
+  private startTime: number;
+  private fileResults: TestFileResult[] = [];
+  private currentFileResult: TestFileResult | null = null;
+  private currentTestLogFile: string | null = null;
+  private currentTestLogs: string[] = []; // Buffer for current test logs
+  private currentTestFailed: boolean = false;
+  
+  constructor(options: LogOptions = {}) {
+    this.options = options;
+    this.startTime = Date.now();
+  }
+  
+  private format(text: string, color?: string): string {
+    if (this.options.noColor || !color) {
+      return text;
+    }
+    return cs(text, color as any);
+  }
+  
+  private log(message: string) {
+    if (this.options.json) {
+      // For JSON mode, skip console output
+      // JSON output is handled by logJson method
+      return;
+    }
+    
+    console.log(message);
+    
+    // Log to the current test file log if we're in a test and --logfile is specified
+    if (this.currentTestLogFile) {
+      this.logToTestFile(message);
+    }
+  }
+  
+  private logToFile(message: string) {
+    // This method is no longer used since we use logToTestFile for individual test logs
+    // Keeping it for potential future use with a global log file
+  }
+  
+  private logToTestFile(message: string) {
+    try {
+      // Remove ANSI color codes for file logging
+      const cleanMessage = message.replace(/\u001b\[[0-9;]*m/g, '');
+      
+      // Append to test log file
+      fs.appendFileSync(this.currentTestLogFile, cleanMessage + '\n');
+    } catch (error) {
+      // Silently fail to avoid disrupting the test run
+    }
+  }
+  
+  private logJson(data: any) {
+    const jsonString = JSON.stringify(data);
+    console.log(jsonString);
+    
+    // Also log to test file if --logfile is specified
+    if (this.currentTestLogFile) {
+      this.logToTestFile(jsonString);
+    }
+  }
+  
+  // Section separators
+  sectionStart(title: string) {
+    if (this.options.quiet || this.options.json) return;
+    this.log(this.format(`\n━━━ ${title} ━━━`, 'cyan'));
+  }
+  
+  sectionEnd() {
+    if (this.options.quiet || this.options.json) return;
+    this.log(this.format('─'.repeat(50), 'dim'));
+  }
+  
+  // Progress indication
+  progress(current: number, total: number, message: string) {
+    if (this.options.quiet || this.options.json) return;
+    const percentage = Math.round((current / total) * 100);
+    const filled = Math.round((current / total) * 20);
+    const empty = 20 - filled;
+    
+    this.log(this.format(`\n📊 Progress: ${current}/${total} (${percentage}%)`, 'cyan'));
+    this.log(this.format(`[${'█'.repeat(filled)}${'░'.repeat(empty)}] ${message}`, 'dim'));
+  }
+  
+  // Test discovery
+  testDiscovery(count: number, pattern: string, executionMode: string) {
+    if (this.options.json) {
+      this.logJson({ event: 'discovery', count, pattern, executionMode });
+      return;
+    }
+    
+    if (this.options.quiet) {
+      this.log(`Found ${count} tests`);
+    } else {
+      this.log(this.format(`\n🔍 Test Discovery`, 'bold'));
+      this.log(this.format(`   Mode: ${executionMode}`, 'dim'));
+      this.log(this.format(`   Pattern: ${pattern}`, 'dim'));
+      this.log(this.format(`   Found: ${count} test file(s)`, 'green'));
+    }
+  }
+  
+  // Test execution
+  testFileStart(filename: string, runtime: string, index: number, total: number) {
+    this.currentFileResult = {
+      file: filename,
+      passed: 0,
+      failed: 0,
+      total: 0,
+      duration: 0,
+      tests: []
+    };
+    
+    // Reset test-specific state
+    this.currentTestLogs = [];
+    this.currentTestFailed = false;
+    
+    // Only set up test log file if --logfile option is specified
+    if (this.options.logFile) {
+      const baseFilename = path.basename(filename, '.ts');
+      this.currentTestLogFile = path.join('.nogit', 'testlogs', `${baseFilename}.log`);
+      
+      // Ensure the directory exists
+      const logDir = path.dirname(this.currentTestLogFile);
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+      
+      // Clear the log file for this test
+      fs.writeFileSync(this.currentTestLogFile, '');
+    }
+    
+    if (this.options.json) {
+      this.logJson({ event: 'fileStart', filename, runtime, index, total });
+      return;
+    }
+    
+    if (this.options.quiet) return;
+    
+    this.log(this.format(`\n▶️  ${filename} (${index}/${total})`, 'blue'));
+    this.log(this.format(`   Runtime: ${runtime}`, 'dim'));
+  }
+  
+  testResult(testName: string, passed: boolean, duration: number, error?: string) {
+    if (this.currentFileResult) {
+      this.currentFileResult.tests.push({ name: testName, passed, duration, error });
+      this.currentFileResult.total++;
+      if (passed) {
+        this.currentFileResult.passed++;
+      } else {
+        this.currentFileResult.failed++;
+        this.currentTestFailed = true;
+      }
+      this.currentFileResult.duration += duration;
+    }
+    
+    if (this.options.json) {
+      this.logJson({ event: 'testResult', testName, passed, duration, error });
+      return;
+    }
+    
+    // If test failed and we have buffered logs, show them now
+    if (!passed && this.currentTestLogs.length > 0 && !this.options.verbose) {
+      this.log(this.format('   📋 Console output from failed test:', 'yellow'));
+      this.currentTestLogs.forEach(logMessage => {
+        this.log(this.format(`   ${logMessage}`, 'dim'));
+      });
+    }
+    
+    const icon = passed ? '✅' : '❌';
+    const color = passed ? 'green' : 'red';
+    
+    if (this.options.quiet) {
+      this.log(`${icon} ${testName}`);
+    } else {
+      this.log(this.format(`   ${icon} ${testName} (${duration}ms)`, color));
+      if (error && !passed) {
+        this.log(this.format(`      ${error}`, 'red'));
+      }
+    }
+    
+    // Clear logs after each test
+    this.currentTestLogs = [];
+  }
+  
+  testFileEnd(passed: number, failed: number, duration: number) {
+    if (this.currentFileResult) {
+      this.fileResults.push(this.currentFileResult);
+      this.currentFileResult = null;
+    }
+    
+    if (this.options.json) {
+      this.logJson({ event: 'fileEnd', passed, failed, duration });
+      return;
+    }
+    
+    if (!this.options.quiet) {
+      const total = passed + failed;
+      const status = failed === 0 ? 'PASSED' : 'FAILED';
+      const color = failed === 0 ? 'green' : 'red';
+      this.log(this.format(`   Summary: ${passed}/${total} ${status}`, color));
+    }
+    
+    // Clear the current test log file reference only if using --logfile
+    if (this.options.logFile) {
+      this.currentTestLogFile = null;
+    }
+  }
+  
+  // TAP output forwarding (for TAP protocol messages)
+  tapOutput(message: string, isError: boolean = false) {
+    if (this.options.json) return;
+    
+    // Never show raw TAP protocol messages in console
+    // They are already processed by TapParser and shown in our format
+    
+    // Always log to test file if --logfile is specified
+    if (this.currentTestLogFile) {
+      this.logToTestFile(`   ${message}`);
+    }
+  }
+  
+  // Console output from test files (non-TAP output)
+  testConsoleOutput(message: string) {
+    if (this.options.json) return;
+    
+    // In verbose mode, show console output immediately
+    if (this.options.verbose) {
+      this.log(this.format(`   ${message}`, 'dim'));
+    } else {
+      // In non-verbose mode, buffer the logs
+      this.currentTestLogs.push(message);
+    }
+    
+    // Always log to test file if --logfile is specified
+    if (this.currentTestLogFile) {
+      this.logToTestFile(`   ${message}`);
+    }
+  }
+  
+  // Browser console
+  browserConsole(message: string, level: string = 'log') {
+    if (this.options.json) {
+      this.logJson({ event: 'browserConsole', message, level });
+      return;
+    }
+    
+    if (!this.options.quiet) {
+      const prefix = level === 'error' ? '🌐❌' : '🌐';
+      const color = level === 'error' ? 'red' : 'magenta';
+      this.log(this.format(`   ${prefix} ${message}`, color));
+    }
+  }
+  
+  // Test error details display
+  testErrorDetails(errorMessage: string) {
+    if (this.options.json) {
+      this.logJson({ event: 'testError', error: errorMessage });
+      return;
+    }
+    
+    if (!this.options.quiet) {
+      this.log(this.format('      Error details:', 'red'));
+      errorMessage.split('\n').forEach(line => {
+        this.log(this.format(`        ${line}`, 'red'));
+      });
+    }
+    
+    // Always log to test file if --logfile is specified
+    if (this.currentTestLogFile) {
+      this.logToTestFile(`   Error: ${errorMessage}`);
+    }
+  }
+  
+  // Final summary
+  summary() {
+    const totalDuration = Date.now() - this.startTime;
+    const summary: TestSummary = {
+      totalFiles: this.fileResults.length,
+      totalTests: this.fileResults.reduce((sum, r) => sum + r.total, 0),
+      totalPassed: this.fileResults.reduce((sum, r) => sum + r.passed, 0),
+      totalFailed: this.fileResults.reduce((sum, r) => sum + r.failed, 0),
+      totalDuration,
+      fileResults: this.fileResults
+    };
+    
+    if (this.options.json) {
+      this.logJson({ event: 'summary', summary });
+      return;
+    }
+    
+    if (this.options.quiet) {
+      const status = summary.totalFailed === 0 ? 'PASSED' : 'FAILED';
+      this.log(`\nSummary: ${summary.totalPassed}/${summary.totalTests} | ${totalDuration}ms | ${status}`);
+      return;
+    }
+    
+    // Detailed summary
+    this.log(this.format('\n📊 Test Summary', 'bold'));
+    this.log(this.format('┌────────────────────────────────┐', 'dim'));
+    this.log(this.format(`│ Total Files:    ${summary.totalFiles.toString().padStart(14)} │`, 'white'));
+    this.log(this.format(`│ Total Tests:    ${summary.totalTests.toString().padStart(14)} │`, 'white'));
+    this.log(this.format(`│ Passed:         ${summary.totalPassed.toString().padStart(14)} │`, 'green'));
+    this.log(this.format(`│ Failed:         ${summary.totalFailed.toString().padStart(14)} │`, summary.totalFailed > 0 ? 'red' : 'green'));
+    this.log(this.format(`│ Duration:       ${totalDuration.toString().padStart(14)}ms │`, 'white'));
+    this.log(this.format('└────────────────────────────────┘', 'dim'));
+    
+    // File results
+    if (summary.totalFailed > 0) {
+      this.log(this.format('\n❌ Failed Tests:', 'red'));
+      this.fileResults.forEach(fileResult => {
+        if (fileResult.failed > 0) {
+          this.log(this.format(`\n   ${fileResult.file}`, 'yellow'));
+          fileResult.tests.filter(t => !t.passed).forEach(test => {
+            this.log(this.format(`      ❌ ${test.name}`, 'red'));
+            if (test.error) {
+              this.log(this.format(`         ${test.error}`, 'dim'));
+            }
+          });
+        }
+      });
+    }
+    
+    // Performance metrics
+    if (this.options.verbose) {
+      const avgDuration = Math.round(totalDuration / summary.totalTests);
+      const slowestTest = this.fileResults
+        .flatMap(r => r.tests)
+        .sort((a, b) => b.duration - a.duration)[0];
+      
+      this.log(this.format('\n⏱️  Performance Metrics:', 'cyan'));
+      this.log(this.format(`   Average per test: ${avgDuration}ms`, 'white'));
+      if (slowestTest) {
+        this.log(this.format(`   Slowest test: ${slowestTest.name} (${slowestTest.duration}ms)`, 'yellow'));
+      }
+    }
+    
+    // Final status
+    const status = summary.totalFailed === 0 ? 'ALL TESTS PASSED! 🎉' : 'SOME TESTS FAILED! ❌';
+    const statusColor = summary.totalFailed === 0 ? 'green' : 'red';
+    this.log(this.format(`\n${status}`, statusColor));
+  }
+  
+  // Error display
+  error(message: string, file?: string, stack?: string) {
+    if (this.options.json) {
+      this.logJson({ event: 'error', message, file, stack });
+      return;
+    }
+    
+    if (this.options.quiet) {
+      console.error(`ERROR: ${message}`);
+    } else {
+      this.log(this.format('\n⚠️  Error', 'red'));
+      if (file) this.log(this.format(`   File: ${file}`, 'yellow'));
+      this.log(this.format(`   ${message}`, 'red'));
+      if (stack && this.options.verbose) {
+        this.log(this.format(`   Stack:`, 'dim'));
+        this.log(this.format(stack.split('\n').map(line => `     ${line}`).join('\n'), 'dim'));
+      }
+    }
+  }
+}

ts/tstest.logprefixes.ts

@@ -1,7 +1,8 @@
-import * as plugins from './tstest.plugins';
-import { coloredString as cs } from '@pushrocks/consolecolor';
+import * as plugins from './tstest.plugins.js';
+import { coloredString as cs } from '@push.rocks/consolecolor';
 
 export const TapPrefix = cs(`::TAP::`, 'pink', 'black');
+export const TapPretaskPrefix = cs(`::PRETASK::`, 'cyan', 'black');
 export const TapErrorPrefix = cs(` !!!TAP PROTOCOL ERROR!!! `, 'red', 'black');
 
 export const TsTestPrefix = cs(`**TSTEST**`, 'pink', 'black');

ts/tstest.paths.ts

@@ -1,5 +1,5 @@
-import * as plugins from './tstest.plugins';
+import * as plugins from './tstest.plugins.js';
 
 export const cwd = process.cwd();
 export const testDir = plugins.path.join(cwd, './test/');
-export const binDirectory = plugins.path.join(cwd, 'node_modules/.bin');
+export const binDirectory = plugins.path.join(cwd, './node_modules/.bin');

ts/tstest.plugins.ts

@@ -1,14 +1,49 @@
 // node native
 import * as path from 'path';
 
-// @pushrocks scope
-import * as consolecolor from '@pushrocks/consolecolor';
-import * as smartfile from '@pushrocks/smartfile';
-import * as smartlog from '@pushrocks/smartlog';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartshell from '@pushrocks/smartshell';
+export { path };
+
+// @apiglobal scope
+import * as typedserver from '@api.global/typedserver';
+
+export {
+  typedserver
+}
+
+// @push.rocks scope
+import * as consolecolor from '@push.rocks/consolecolor';
+import * as smartbrowser from '@push.rocks/smartbrowser';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartshell from '@push.rocks/smartshell';
+import * as tapbundle from '@push.rocks/tapbundle';
+
+export {
+  consolecolor,
+  smartbrowser,
+  smartdelay,
+  smartfile,
+  smartlog,
+  smartpromise,
+  smartshell,
+  tapbundle,
+};
+
+// @gitzone scope
+import * as tsbundle from '@git.zone/tsbundle';
+
+export { tsbundle };
 
 // sindresorhus
-import * as figures from 'figures';
+import figures from 'figures';
 
-export { consolecolor, figures, path, smartfile, smartlog, smartpromise, smartshell };
+export { figures };
+
+// third party
+import * as ws from 'ws';
+
+export {
+  ws
+}

tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}