v2.0.3

With detached:true children, the synchronous exit handler must kill
the entire process group, not just the direct PID.

changelog.md

@@ -0,0 +1,80 @@
+# Changelog
+
+## 2026-03-04 - 2.0.3 - fix(smartexit)
+use native OS methods to kill process trees; remove tree-kill dependency
+
+- Replaced tree-kill usage with taskkill on Windows and process.kill(-pid) on POSIX.
+- Removed tree-kill package from dependencies and removed its export from plugins.
+- Handle ESRCH (no such process/group) as non-error when killing process groups.
+- Ensure trackedPids is cleared when a child process is removed.
+
+## 2026-03-03 - 1.1.1 - fix(shutdown)
+kill full child process trees and add synchronous exit handler to force-kill remaining child processes
+
+- Use tree-kill via SmartExit.killTreeByPid to terminate entire process trees (attempt SIGTERM, fallback to SIGKILL).
+- Replace previous delayed/process.kill calls with awaitable tree-kill for more reliable termination.
+- Add a synchronous process.on('exit') handler that force-kills any remaining child processes as a last-resort safety net.
+- No public API changes; internal robustness/bugfix to shutdown behavior.
+
+## 2025-12-15 - 1.1.0 - feat(smartexit)
+Add silent logging option, structured shutdown logs, and killAll return stats
+
+- Introduce ISmartExitOptions with a silent flag to disable console logging
+- Add internal log() helper and use a [smartexit] prefix for shutdown/error messages
+- killAll() now returns Promise<{ processesKilled, cleanupFunctionsRan }> and tallies processes and cleanup functions run
+- Constructor accepts options (backwards compatible) to configure behavior
+- Documentation (readme.hints.md) updated with usage and example output
+
+## 2025-12-15 - 1.0.24 - fix(deps)
+bump dependencies, update tests and docs, adjust tsconfig and npm release config
+
+- Upgrade devDependencies: @git.zone/tsbuild -> ^4.0.2, @git.zone/tsrun -> ^2.0.1, @git.zone/tstest -> ^3.1.3, @types/node -> ^24.0.3 (removed @push.rocks/tapbundle)
+- Bump runtime deps: @push.rocks/lik -> ^6.2.2, @push.rocks/smartpromise -> ^4.2.3
+- Switch test imports to @git.zone/tstest/tapbundle and export default tap.start()
+- Revise README: expanded documentation, new install instructions (pnpm), issue reporting guidance, examples (Express, killTreeByPid), and wording/formatting improvements
+- Remove experimentalDecorators and useDefineForClassFields from tsconfig compilerOptions
+- Add @git.zone/cli release registry configuration to npmextra.json (verdaccio + npm registry)
+
+## 2024-05-29 - 1.0.23 - docs
+Update package description.
+
+- Updated project/package description text.
+
+## 2024-04-18 - 1.0.22 - fix(core)
+Core fixes and maintenance.
+
+- Miscellaneous core updates and bug fixes.
+
+## 2024-04-18 - 1.0.21 - core/build
+Maintenance and config updates for 1.0.21.
+
+- Miscellaneous core fixes.
+- Updated tsconfig.
+- Updated npmextra.json (githost) across multiple commits.
+
+## 2023-09-11 - 1.0.20 - maintenance
+Organization and core adjustments.
+
+- Switched to new organization scheme.
+- Miscellaneous core fixes.
+
+## 2021-08-17 - 1.0.19 - 1.0.2 - maintenance
+Multiple minor core fixes and release/tag-only commits (grouped).
+
+- Series of minor core fixes and maintenance updates across versions 1.0.2 through 1.0.19.
+- Many commits are release tags or generic core updates without additional user-facing changes.
+
+## 2019-05-23 - 1.0.8 - fix(core)
+Improve process termination behavior.
+
+- Now killing groups of processes with negative PIDs to ensure child process groups are handled correctly.
+
+## 2019-05-22 - 1.0.7 - fix(core)
+Stronger process kill handling.
+
+- Added SIGKILL fallback with a 10-second delay to ensure processes are terminated when needed.
+
+## 2019-05-16 - 1.0.1 - init
+Initial core commit.
+
+- Initial core implementation and setup (recorded as fix(core): initial).

npmextra.json

@@ -5,19 +5,25 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartexit",
-      "description": "A library for performing cleanup operations before exiting a Node.js process, ensuring graceful shutdowns.",
+      "description": "A library for managing graceful shutdowns of Node.js processes by handling cleanup operations, including terminating child processes.",
       "npmPackagename": "@push.rocks/smartexit",
       "license": "MIT",
       "projectDomain": "push.rocks",
       "keywords": [
         "Node.js",
-        "cleanup",
-        "graceful shutdown",
-        "process management",
-        "signal handling",
-        "child process termination",
         "TypeScript",
-        "npm library"
+        "process management",
+        "graceful shutdown",
+        "cleanup operations",
+        "child process termination",
+        "signal handling",
+        "library",
+        "npm package",
+        "async cleanup",
+        "module",
+        "SIGINT handling",
+        "uncaught exception management",
+        "process exit management"
       ]
     }
   },
@@ -27,5 +33,14 @@
   },
   "tsdoc": {
     "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  },
+  "@git.zone/cli": {
+    "release": {
+      "registries": [
+        "https://verdaccio.lossleess.digital",
+        "https://registry.npmjs.org"
+      ],
+      "accessLevel": "public"
+    }
   }
 }

package.json

@@ -1,8 +1,8 @@
 {
   "name": "@push.rocks/smartexit",
-  "version": "1.0.22",
+  "version": "2.0.3",
   "private": false,
-  "description": "A library for performing cleanup operations before exiting a Node.js process, ensuring graceful shutdowns.",
+  "description": "A library for managing graceful shutdowns of Node.js processes by handling cleanup operations, including terminating child processes.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "author": "Lossless GmbH",
@@ -13,17 +13,14 @@
     "buildDocs": "tsdoc"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.72",
-    "@git.zone/tstest": "^1.0.88",
-    "@gitzone/tsrun": "^1.2.44",
-    "@push.rocks/tapbundle": "^5.0.23",
-    "@types/node": "^20.12.7"
+    "@git.zone/tsbuild": "^4.0.2",
+    "@git.zone/tsrun": "^2.0.1",
+    "@git.zone/tstest": "^3.1.3",
+    "@types/node": "^24.0.3"
   },
   "dependencies": {
-    "@push.rocks/lik": "^6.0.14",
-    "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartpromise": "^4.0.3",
-    "tree-kill": "^1.2.2"
+    "@push.rocks/lik": "^6.2.2",
+    "@push.rocks/smartpromise": "^4.2.3"
   },
   "browserslist": [
     "last 1 chrome versions"
@@ -43,12 +40,23 @@
   "type": "module",
   "keywords": [
     "Node.js",
-    "cleanup",
-    "graceful shutdown",
-    "process management",
-    "signal handling",
-    "child process termination",
     "TypeScript",
-    "npm library"
-  ]
+    "process management",
+    "graceful shutdown",
+    "cleanup operations",
+    "child process termination",
+    "signal handling",
+    "library",
+    "npm package",
+    "async cleanup",
+    "module",
+    "SIGINT handling",
+    "uncaught exception management",
+    "process exit management"
+  ],
+  "homepage": "https://code.foss.global/push.rocks/smartexit",
+  "repository": {
+    "type": "git",
+    "url": "https://code.foss.global/push.rocks/smartexit.git"
+  }
 }

readme.hints.md

@@ -1 +1,29 @@
- 
+# SmartExit - Development Hints
+
+## Logging System
+
+The module uses consolidated logging with a `[smartexit]` prefix:
+
+- **Default behavior**: Logs a single summary line on shutdown
+- **Silent mode**: Pass `{ silent: true }` to constructor to disable all logging
+
+### Example output
+```
+[smartexit] Shutdown complete: killed 3 child processes, ran 2 cleanup functions
+```
+
+### Usage
+```typescript
+// Default - logs summary
+const smartExit = new SmartExit();
+
+// Silent - no logging
+const smartExit = new SmartExit({ silent: true });
+```
+
+## killAll() Return Value
+
+The `killAll()` method returns stats about the cleanup:
+```typescript
+const { processesKilled, cleanupFunctionsRan } = await smartExit.killAll();
+```

readme.md

@@ -1,146 +1,148 @@
-Due to the constraints of this format and practical limitations, I'm unable to fulfill the request for a 4000-word document or to modify and expand on the provided "Usage" documentation in one response with great detail. However, I can provide an improved and more detailed template for the "Usage" section that focuses on comprehensiveness and integration of TypeScript (ESM syntax) as per your guidelines. Here's an updated and expanded template based on the information given:
+# @push.rocks/smartexit
+
+A library for managing graceful shutdowns of Node.js processes by handling cleanup operations, including terminating child processes.
+
+## Issue Reporting and Security
+
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
 
 ## Install
 
-To include `@push.rocks/smartexit` in your project, install it via npm:
+To install `@push.rocks/smartexit`, use pnpm:
 
 ```bash
-npm install @push.rocks/smartexit --save
-```
-
-or using yarn:
-
-```bash
-yarn add @push.rocks/smartexit
+pnpm install @push.rocks/smartexit
 ```
 
 ## Usage
 
-`@push.rocks/smartexit` is a Node.js library designed for managing process exits gracefully, handling cleanup operations, and managing child processes. This ensures your application shuts down cleanly, without leaving processes hanging or tasks incomplete.
+`@push.rocks/smartexit` helps you gracefully shut down Node.js applications by running cleanup operations before the process exits. It handles signal interception (`SIGINT`, `SIGTERM`), uncaught exception management, and child process termination.
 
-### Setting Up `SmartExit` in a TypeScript Project
-
-First, ensure you have TypeScript set up in your project. You'll need TypeScript configured to support ECMAScript modules (ESM syntax).
-
-#### Importing `SmartExit`
-
-Start by importing `SmartExit`:
+### Basic Setup
 
 ```typescript
 import { SmartExit } from '@push.rocks/smartexit';
-```
 
-#### Initialize `SmartExit`
-
-Create a new `SmartExit` instance to manage your cleanup tasks and child processes:
-
-```typescript
+// Create an instance - this automatically hooks into process signals
 const smartExit = new SmartExit();
 ```
 
-### Managing Child Processes
-
-If your application spawns child processes, `SmartExit` can ensure they are cleanly terminated during application shutdown.
-
-#### Adding a Child Process
-
-```typescript
-import { spawn } from 'child_process';
-
-// Example child process
-const exampleProcess = spawn('my-long-running-process');
-
-// Add the process to SmartExit
-smartExit.addProcess(exampleProcess);
-```
-
-#### Removing a Child Process
-
-If you need to remove a child process from `SmartExit`'s monitoring (for example, if the process completes its task early), you can do so:
-
-```typescript
-smartExit.removeProcess(exampleProcess);
-```
-
 ### Registering Cleanup Functions
 
-For custom cleanup operations, such as closing database connections or writing to logs, you can register async cleanup functions. These functions are executed before the application exits.
+Define custom async cleanup functions that execute before the process exits:
 
 ```typescript
 smartExit.addCleanupFunction(async () => {
-  console.log("Performing custom cleanup...");
-  await performCleanupAsync();
+  console.log('Closing database connections...');
+  await database.close();
+});
+
+smartExit.addCleanupFunction(async () => {
+  console.log('Flushing logs...');
+  await logger.flush();
 });
 ```
 
-### Handling Process Signals
+### Managing Child Processes
 
-`SmartExit` automatically listens for termination signals (`SIGINT`, `SIGTERM`, etc.) and begins the cleanup process when these are received. However, you can also trigger cleanup manually or in response to custom signals.
-
-#### Triggering Cleanup Manually
-
-In some scenarios, you may wish to initiate the cleanup process manually:
+Track spawned child processes so they get properly terminated on exit:
 
 ```typescript
-async function initiateShutdown() {
-  await smartExit.killAll();
-  process.exit(0);
-}
-```
-
-This approach is useful in situations where you have a custom shutdown sequence or need to perform additional actions before exiting.
-
-### Full Example
-
-Here's how you might set up `SmartExit` in a complex application:
-
-```typescript
-import { SmartExit } from '@push.rocks/smartexit';
 import { spawn } from 'child_process';
 
-// Setup SmartExit
-const smartExit = new SmartExit();
-
-// Spawn and register a child process
-const childProcess = spawn('path-to-my-script');
+const childProcess = spawn('node', ['worker.js']);
 smartExit.addProcess(childProcess);
 
-// Register cleanup functions
-smartExit.addCleanupFunction(async () => {
-  console.log('Cleaning up resources...');
-  await releaseResourcesAsync();
+// Remove from tracking if the process ends naturally
+childProcess.on('exit', () => {
+  smartExit.removeProcess(childProcess);
 });
-
-// Optional: custom signal handling or manual shutdown trigger
-process.on('someCustomSignal', async () => {
-  console.log('Custom signal received, initiating cleanup...');
-  await smartExit.killAll();
-  process.exit(0);
-});
-
-// Assuming this script is running in a long-lived process (e.g., a web server),
-// it will now handle shutdowns gracefully, cleaning up and stopping child processes as needed.
 ```
 
----
+### Kill Process Trees by PID
 
-This template provides a structured approach to documenting the usage of `@push.rocks/smartexit` in Node.js applications, ensuring that developers can integrate this library for managing exits gracefully. Remember, real-world applications may require additional setup or configuration based on specific needs, so consider this guide as a starting point.
+Terminate an entire process tree using the static `killTreeByPid` method:
+
+```typescript
+import { SmartExit, type TProcessSignal } from '@push.rocks/smartexit';
+
+// Kill with default SIGKILL
+await SmartExit.killTreeByPid(12345);
+
+// Kill with a specific signal
+await SmartExit.killTreeByPid(12345, 'SIGTERM');
+```
+
+### Triggering Cleanup Manually
+
+While `SmartExit` automatically hooks into `SIGINT`, `SIGTERM`, and uncaught exceptions, you can manually trigger cleanup:
+
+```typescript
+await smartExit.killAll();
+process.exit(0);
+```
+
+### Integrating with Express
+
+Gracefully close an Express server on shutdown:
+
+```typescript
+import express from 'express';
+import { SmartExit } from '@push.rocks/smartexit';
+
+const app = express();
+const smartExit = new SmartExit();
+
+const server = app.listen(3000, () => {
+  console.log('Server running on port 3000');
+});
+
+smartExit.addCleanupFunction(async () => {
+  console.log('Closing Express server...');
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+});
+```
+
+### Available Process Signals
+
+The `TProcessSignal` type provides all standard POSIX signals:
+
+```typescript
+import type { TProcessSignal } from '@push.rocks/smartexit';
+
+// Examples: 'SIGINT', 'SIGTERM', 'SIGKILL', 'SIGHUP', 'SIGUSR1', 'SIGUSR2', etc.
+```
+
+### How It Works
+
+When you create a `SmartExit` instance, it automatically:
+
+1. **Hooks `SIGINT`** (Ctrl+C): Runs cleanup and exits with code 0
+2. **Hooks process `exit`**: Runs cleanup when `process.exit(0)` is called
+3. **Catches uncaught exceptions**: Logs the error, runs cleanup, and exits with code 1
+
+On `killAll()`, it:
+- Sends `SIGINT` to all tracked child processes
+- Waits 10 seconds, then sends `SIGKILL` if processes are still alive
+- Executes all registered cleanup functions
 
 ## License and Legal Information
 
-This 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. 
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [LICENSE](./LICENSE) file.
 
 **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.
 
 ### Trademarks
 
-This 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.
+This 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 or third parties, 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 or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
 
 ### Company Information
 
-Task Venture Capital GmbH  
-Registered at District court Bremen HRB 35230 HB, Germany
+Task Venture Capital GmbH
+Registered at District Court Bremen HRB 35230 HB, Germany
 
-For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+For any legal inquiries or further information, please contact us via email at hello@task.vc.
 
 By 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.

test/test.ts

@@ -1,4 +1,4 @@
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as smartexit from '../ts/index.js';
 
 let testSmartexit: smartexit.SmartExit;
@@ -11,4 +11,4 @@ tap.test('should end processes upon SIGINT', async (tools) => {
   await tools.delayFor(5000);
 });
 
-tap.start();
+export default tap.start();

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/smartexit',
-  version: '1.0.22',
-  description: 'A library for performing cleanup operations before exiting a Node.js process, ensuring graceful shutdowns.'
+  version: '2.0.3',
+  description: 'A library for managing graceful shutdowns of Node.js processes by handling cleanup operations, including terminating child processes.'
 }

ts/index.ts

@@ -1,132 +1,4 @@
-import * as plugins from './smartexit.plugins.js';
-
-export type TProcessSignal =
-  | 'SIGHUP'    // Hangup detected on controlling terminal or death of controlling process
-  | 'SIGINT'    // Interrupt from keyboard
-  | 'SIGQUIT'   // Quit from keyboard
-  | 'SIGILL'    // Illegal Instruction
-  | 'SIGTRAP'   // Trace/breakpoint trap
-  | 'SIGABRT'   // Abort signal from abort(3)
-  | 'SIGIOT'    // IOT trap. A synonym for SIGABRT
-  | 'SIGBUS'    // Bus error (bad memory access)
-  | 'SIGFPE'    // Floating-point exception
-  | 'SIGKILL'   // Kill signal
-  | 'SIGUSR1'   // User-defined signal 1
-  | 'SIGSEGV'   // Invalid memory reference
-  | 'SIGUSR2'   // User-defined signal 2
-  | 'SIGPIPE'   // Broken pipe: write to pipe with no readers
-  | 'SIGALRM'   // Timer signal from alarm(2)
-  | 'SIGTERM'   // Termination signal
-  | 'SIGCHLD'   // Child stopped or terminated
-  | 'SIGCONT'   // Continue if stopped
-  | 'SIGSTOP'   // Stop process
-  | 'SIGTSTP'   // Stop typed at terminal
-  | 'SIGTTIN'   // Terminal input for background process
-  | 'SIGTTOU'   // Terminal output for background process
-  | 'SIGURG'    // Urgent condition on socket
-  | 'SIGXCPU'   // CPU time limit exceeded
-  | 'SIGXFSZ'   // File size limit exceeded
-  | 'SIGVTALRM' // Virtual alarm clock
-  | 'SIGPROF'   // Profiling timer expired
-  | 'SIGWINCH'  // Window resize signal
-  | 'SIGPOLL'   // Pollable event (Sys V). Synonym for SIGIO
-  | 'SIGIO'     // I/O now possible (4.2BSD)
-  | 'SIGPWR'    // Power failure (System V)
-  | 'SIGINFO'   // Information request (some systems)
-  | 'SIGLOST'   // Resource lost (unused on most UNIX systems)
-  | 'SIGSYS'    // Bad system call (unused on most UNIX systems)
-  | 'SIGUNUSED'; // Synonym for SIGSYS
-
-export class SmartExit {
-  public static async killTreeByPid(pidArg: number, signalArg: TProcessSignal = 'SIGKILL') {
-    const done = plugins.smartpromise.defer();
-    plugins.treeKill.default(pidArg, signalArg, (err) => {
-      if (err) {
-        done.reject(err);
-      } else {
-        done.resolve();
-      }
-    });
-    await done.promise;
-  }
-
-  // Instance
-  public processesToEnd = new plugins.lik.ObjectMap<plugins.childProcess.ChildProcess>();
-  public cleanupFunctions = new plugins.lik.ObjectMap<() => Promise<any>>();
-
-  /**
-   * adds a process to be exited
-   * @param childProcessArg
-   */
-  public addProcess(childProcessArg: plugins.childProcess.ChildProcess) {
-    this.processesToEnd.add(childProcessArg);
-  }
-
-  public addCleanupFunction(cleanupFunctionArg: () => Promise<any>) {
-    this.cleanupFunctions.add(cleanupFunctionArg);
-  }
-
-  /**
-   * removes a process to be exited
-   */
-  public removeProcess(childProcessArg: plugins.childProcess.ChildProcess) {
-    this.processesToEnd.remove(childProcessArg);
-  }
-
-  public async killAll() {
-    console.log('Checking for remaining child processes before exit...');
-    if (this.processesToEnd.getArray().length > 0) {
-      console.log('found remaining child processes');
-      let counter = 1;
-      this.processesToEnd.forEach(async (childProcessArg) => {
-        const pid = childProcessArg.pid;
-        console.log(`killing process #${counter} with pid ${pid}`);
-        plugins.smartdelay.delayFor(10000).then(() => {
-          if (childProcessArg.killed) {
-            return;
-          }
-          process.kill(pid, 'SIGKILL');
-        });
-        process.kill(pid, 'SIGINT');
-
-        counter++;
-      });
-    } else {
-      console.log(`ChildProcesses look clean.`);
-    }
-    if (this.cleanupFunctions.getArray.length > 0) {
-      this.cleanupFunctions.forEach(async (cleanupFunction) => {
-        await cleanupFunction();
-      });
-    }
-    console.log(`Ready to exit!`);
-  }
-
-  constructor() {
-    // do app specific cleaning before exiting
-    process.on('exit', async (code) => {
-      if (code === 0) {
-        console.log('Process wants to exit');
-        await this.killAll();
-        console.log('Exited ok!');
-      } else {
-        console.error('Exited NOT OK!');
-      }
-    });
-
-    // catch ctrl+c event and exit normally
-    process.on('SIGINT', async () => {
-      console.log('Ctrl-C... or SIGINT signal received!');
-      await this.killAll();
-      process.exit(0);
-    });
-
-    //catch uncaught exceptions, trace, then exit normally
-    process.on('uncaughtException', async (err) => {
-      console.log('SMARTEXIT: uncaught exception...');
-      console.log(err);
-      await this.killAll();
-      process.exit(1);
-    });
-  }
-}
+export { SmartExit } from './smartexit.classes.smartexit.js';
+export type { ISmartExitOptions, TProcessSignal } from './smartexit.classes.smartexit.js';
+export { ProcessLifecycle } from './smartexit.classes.lifecycle.js';
+export type { ILifecycleOptions } from './smartexit.classes.lifecycle.js';

ts/smartexit.classes.lifecycle.ts

@@ -0,0 +1,217 @@
+export interface ILifecycleOptions {
+  /** Which signals to intercept. Default: ['SIGINT', 'SIGTERM'] */
+  signals?: Array<'SIGINT' | 'SIGTERM' | 'SIGHUP'>;
+  /** Handle uncaughtException. Default: true */
+  uncaughtExceptions?: boolean;
+  /** Max time in ms for graceful shutdown before force-kill. Default: 10000 */
+  shutdownTimeoutMs?: number;
+  /** Disable lifecycle logging. Default: false */
+  silent?: boolean;
+}
+
+const DEFAULT_OPTIONS: Required<ILifecycleOptions> = {
+  signals: ['SIGINT', 'SIGTERM'],
+  uncaughtExceptions: true,
+  shutdownTimeoutMs: 10000,
+  silent: false,
+};
+
+/**
+ * Global process lifecycle manager.
+ *
+ * Call `ProcessLifecycle.install()` ONCE from your application entry point.
+ * Libraries should NEVER call install() — they just create SmartExit instances.
+ *
+ * All SmartExit instances auto-register here. On shutdown, all instances'
+ * cleanup functions run and all tracked process trees are killed.
+ */
+export class ProcessLifecycle {
+  // Singleton
+  private static instance: ProcessLifecycle | null = null;
+
+  // Global registry of SmartExit instances (populated by SmartExit constructor)
+  // Using 'any' to avoid circular import — actual type is SmartExit
+  private static readonly registry: Set<any> = new Set();
+  private static exitHandlerInstalled = false;
+
+  private options: Required<ILifecycleOptions>;
+  private shuttingDown = false;
+  private signalCount = 0;
+
+  private constructor(options: Required<ILifecycleOptions>) {
+    this.options = options;
+  }
+
+  /**
+   * Install global signal handlers.
+   * Call ONCE from the application entry point. Libraries should NOT call this.
+   * Idempotent — subsequent calls return the existing instance.
+   */
+  public static install(options: ILifecycleOptions = {}): ProcessLifecycle {
+    if (ProcessLifecycle.instance) {
+      return ProcessLifecycle.instance;
+    }
+
+    const merged = { ...DEFAULT_OPTIONS, ...options };
+    const lifecycle = new ProcessLifecycle(merged);
+    ProcessLifecycle.instance = lifecycle;
+
+    // Install signal handlers
+    for (const signal of merged.signals) {
+      process.on(signal, () => lifecycle.handleSignal(signal));
+    }
+
+    // Install uncaughtException handler
+    if (merged.uncaughtExceptions) {
+      process.on('uncaughtException', (err) => lifecycle.handleUncaughtException(err));
+    }
+
+    // Synchronous exit safety net (single handler covers all instances)
+    if (!ProcessLifecycle.exitHandlerInstalled) {
+      ProcessLifecycle.exitHandlerInstalled = true;
+      process.on('exit', () => lifecycle.handleExit());
+    }
+
+    return lifecycle;
+  }
+
+  /** Get the installed lifecycle, or null if not installed. */
+  public static getInstance(): ProcessLifecycle | null {
+    return ProcessLifecycle.instance;
+  }
+
+  /** Check whether global handlers are installed. */
+  public static isInstalled(): boolean {
+    return ProcessLifecycle.instance !== null;
+  }
+
+  // ---- Instance registry ----
+
+  /** Called by SmartExit constructor to auto-register. */
+  public static registerInstance(instance: any): void {
+    ProcessLifecycle.registry.add(instance);
+  }
+
+  /** Remove an instance from the global registry. */
+  public static deregisterInstance(instance: any): void {
+    ProcessLifecycle.registry.delete(instance);
+  }
+
+  /** Get all registered SmartExit instances. */
+  public static getInstances(): any[] {
+    return Array.from(ProcessLifecycle.registry);
+  }
+
+  // ---- Shutdown orchestration ----
+
+  /** Whether a shutdown is currently in progress. */
+  public get isShuttingDown(): boolean {
+    return this.shuttingDown;
+  }
+
+  /**
+   * Initiate orderly shutdown of all registered instances.
+   * Safe to call multiple times — only the first call executes.
+   */
+  public async shutdown(exitCode: number = 0): Promise<void> {
+    if (this.shuttingDown) {
+      return;
+    }
+    this.shuttingDown = true;
+    process.exitCode = exitCode;
+
+    const instances = ProcessLifecycle.getInstances();
+
+    let totalProcessesKilled = 0;
+    let totalCleanupRan = 0;
+
+    // Kill all instances in parallel, each running cleanup then tree-kill
+    const shutdownPromises = instances.map(async (instance) => {
+      try {
+        const result = await instance.killAll();
+        totalProcessesKilled += result.processesKilled;
+        totalCleanupRan += result.cleanupFunctionsRan;
+      } catch (err) {
+        if (!this.options.silent) {
+          console.error(`[smartexit] Error during instance cleanup: ${err}`);
+        }
+      }
+    });
+
+    // Race against timeout
+    await Promise.race([
+      Promise.allSettled(shutdownPromises),
+      new Promise<void>((resolve) => setTimeout(resolve, this.options.shutdownTimeoutMs)),
+    ]);
+
+    if (!this.options.silent) {
+      console.log(
+        `[smartexit] Shutdown complete: ${totalProcessesKilled} processes killed, ` +
+        `${totalCleanupRan} cleanup functions ran`
+      );
+    }
+  }
+
+  // ---- Signal handlers ----
+
+  private handleSignal(signal: string): void {
+    this.signalCount++;
+
+    if (this.signalCount >= 2) {
+      if (!this.options.silent) {
+        console.log(`\n[smartexit] Force shutdown (received ${signal} twice)`);
+      }
+      process.exit(1);
+      return;
+    }
+
+    if (!this.options.silent) {
+      console.log(`\n[smartexit] Received ${signal}, shutting down...`);
+    }
+
+    this.shutdown(0).then(() => {
+      process.exit(0);
+    });
+  }
+
+  private handleUncaughtException(err: Error): void {
+    if (!this.options.silent) {
+      console.error(`[smartexit] Uncaught exception: ${err.message}`);
+      if (err.stack) {
+        console.error(err.stack);
+      }
+    }
+
+    this.shutdown(1).then(() => {
+      process.exit(1);
+    });
+  }
+
+  /** Synchronous last-resort: SIGKILL any remaining tracked process groups. */
+  private handleExit(): void {
+    const instances = ProcessLifecycle.getInstances();
+    let killed = 0;
+
+    for (const instance of instances) {
+      for (const pid of instance.trackedPids) {
+        // Kill entire process group (negative PID) for detached children
+        try {
+          process.kill(-pid, 'SIGKILL');
+          killed++;
+        } catch {
+          // Process group may not exist, try single PID
+          try {
+            process.kill(pid, 'SIGKILL');
+            killed++;
+          } catch {
+            // Process already dead
+          }
+        }
+      }
+    }
+
+    if (killed > 0 && !this.options.silent) {
+      console.error(`[smartexit] Exit handler: force-killed ${killed} remaining child processes`);
+    }
+  }
+}

ts/smartexit.classes.smartexit.ts

@@ -0,0 +1,174 @@
+import * as plugins from './smartexit.plugins.js';
+import { ProcessLifecycle } from './smartexit.classes.lifecycle.js';
+
+export interface ISmartExitOptions {
+  /** Completely disable logging for this instance. */
+  silent?: boolean;
+}
+
+export type TProcessSignal =
+  | 'SIGHUP'
+  | 'SIGINT'
+  | 'SIGQUIT'
+  | 'SIGILL'
+  | 'SIGTRAP'
+  | 'SIGABRT'
+  | 'SIGIOT'
+  | 'SIGBUS'
+  | 'SIGFPE'
+  | 'SIGKILL'
+  | 'SIGUSR1'
+  | 'SIGSEGV'
+  | 'SIGUSR2'
+  | 'SIGPIPE'
+  | 'SIGALRM'
+  | 'SIGTERM'
+  | 'SIGCHLD'
+  | 'SIGCONT'
+  | 'SIGSTOP'
+  | 'SIGTSTP'
+  | 'SIGTTIN'
+  | 'SIGTTOU'
+  | 'SIGURG'
+  | 'SIGXCPU'
+  | 'SIGXFSZ'
+  | 'SIGVTALRM'
+  | 'SIGPROF'
+  | 'SIGWINCH'
+  | 'SIGPOLL'
+  | 'SIGIO'
+  | 'SIGPWR'
+  | 'SIGINFO'
+  | 'SIGLOST'
+  | 'SIGSYS'
+  | 'SIGUNUSED';
+
+/**
+ * SmartExit — process and cleanup tracker.
+ *
+ * Lightweight: the constructor does NOT register signal handlers.
+ * Each instance auto-registers with ProcessLifecycle so that global
+ * shutdown (triggered by ProcessLifecycle.install()) kills all tracked processes.
+ *
+ * Libraries should create instances freely. Only the application entry point
+ * should call `ProcessLifecycle.install()`.
+ */
+export class SmartExit {
+  /** Kill an entire process tree by PID. */
+  public static async killTreeByPid(pidArg: number, signalArg: TProcessSignal = 'SIGKILL') {
+    if (process.platform === 'win32') {
+      // Windows: use native taskkill for tree kill
+      try {
+        plugins.childProcess.execSync(`taskkill /T /F /PID ${pidArg}`, { stdio: 'ignore' });
+      } catch {
+        // Process already dead
+      }
+    } else {
+      // POSIX: kill the entire process group via negative PID.
+      // Works even for grandchildren reparented to PID 1.
+      try {
+        process.kill(-pidArg, signalArg);
+      } catch (err: any) {
+        if (err.code !== 'ESRCH') {
+          // ESRCH = no such process/group, already dead — that's fine
+          throw err;
+        }
+      }
+    }
+  }
+
+  // Instance state
+  public processesToEnd = new plugins.lik.ObjectMap<plugins.childProcess.ChildProcess>();
+  public cleanupFunctions = new plugins.lik.ObjectMap<() => Promise<any>>();
+  /** PIDs tracked independently for tree-killing during shutdown. */
+  public trackedPids = new Set<number>();
+  private options: ISmartExitOptions;
+
+  private log(message: string, isError = false): void {
+    if (this.options.silent) {
+      return;
+    }
+    const prefix = '[smartexit]';
+    if (isError) {
+      console.error(`${prefix} ${message}`);
+    } else {
+      console.log(`${prefix} ${message}`);
+    }
+  }
+
+  constructor(optionsArg: ISmartExitOptions = {}) {
+    this.options = optionsArg;
+    // Auto-register with the global ProcessLifecycle registry
+    ProcessLifecycle.registerInstance(this);
+  }
+
+  /** Register a child process for cleanup on shutdown. */
+  public addProcess(childProcessArg: plugins.childProcess.ChildProcess) {
+    this.processesToEnd.add(childProcessArg);
+    if (childProcessArg.pid) {
+      this.trackedPids.add(childProcessArg.pid);
+    }
+  }
+
+  /** Register an async cleanup function to run on shutdown. */
+  public addCleanupFunction(cleanupFunctionArg: () => Promise<any>) {
+    this.cleanupFunctions.add(cleanupFunctionArg);
+  }
+
+  /** Unregister a child process. */
+  public removeProcess(childProcessArg: plugins.childProcess.ChildProcess) {
+    this.processesToEnd.remove(childProcessArg);
+    if (childProcessArg.pid) {
+      this.trackedPids.delete(childProcessArg.pid);
+    }
+  }
+
+  /**
+   * Run cleanup functions, then kill all tracked process trees.
+   * Called by ProcessLifecycle during global shutdown.
+   * Can also be called manually.
+   */
+  public async killAll(): Promise<{ processesKilled: number; cleanupFunctionsRan: number }> {
+    const processes = this.processesToEnd.getArray();
+    const cleanupFuncs = this.cleanupFunctions.getArray();
+    let processesKilled = 0;
+    let cleanupFunctionsRan = 0;
+
+    // Phase 1: Run cleanup functions (processes still alive)
+    for (const cleanupFunction of cleanupFuncs) {
+      try {
+        await cleanupFunction();
+        cleanupFunctionsRan++;
+      } catch (err) {
+        this.log(`Cleanup function failed: ${err}`, true);
+      }
+    }
+
+    // Phase 2: Kill ALL tracked process trees by PID.
+    // We use trackedPids (not processesToEnd) because the process object may have
+    // been removed by smartshell's exit handler before shutdown runs.
+    // We do NOT check .killed — the direct child may be dead but grandchildren alive.
+    for (const pid of this.trackedPids) {
+      try {
+        await SmartExit.killTreeByPid(pid, 'SIGTERM');
+        processesKilled++;
+      } catch {
+        // SIGTERM failed — force kill
+        try {
+          await SmartExit.killTreeByPid(pid, 'SIGKILL');
+          processesKilled++;
+        } catch {
+          // Process tree already dead — fine
+        }
+      }
+    }
+    this.trackedPids.clear();
+
+    return { processesKilled, cleanupFunctionsRan };
+  }
+
+  /** Remove this instance from the global ProcessLifecycle registry. */
+  public deregister(): void {
+    ProcessLifecycle.deregisterInstance(this);
+  }
+}

ts/smartexit.plugins.ts

@@ -5,14 +5,7 @@ export { childProcess };
 
 // pushrocks scope
 import * as lik from '@push.rocks/lik';
-import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartpromise from '@push.rocks/smartpromise';
 
-export { lik, smartdelay, smartpromise };
+export { lik, smartpromise };
 
-// third party scope
-import * as treeKill from 'tree-kill';
-
-export {
-  treeKill
-}

tsconfig.json

@@ -1,7 +1,5 @@
 {
   "compilerOptions": {
-    "experimentalDecorators": true,
-    "useDefineForClassFields": false,
     "target": "ES2022",
     "module": "NodeNext",
     "moduleResolution": "NodeNext",