fix(lifecycle): use process group kill (-pid) in handleExit safety net

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

changelog.md

@@ -0,0 +1,72 @@
+# Changelog
+
+## 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

@@ -33,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,6 +1,6 @@
 {
   "name": "@push.rocks/smartexit",
-  "version": "1.0.23",
+  "version": "2.0.2",
   "private": false,
   "description": "A library for managing graceful shutdowns of Node.js processes by handling cleanup operations, including terminating child processes.",
   "main": "dist_ts/index.js",
@@ -13,16 +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",
+    "@push.rocks/lik": "^6.2.2",
+    "@push.rocks/smartpromise": "^4.2.3",
     "tree-kill": "^1.2.2"
   },
   "browserslist": [
@@ -56,5 +54,10 @@
     "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,126 +1,148 @@
 # @push.rocks/smartexit
 
-A library for performing cleanup operations before exiting a Node.js process, ensuring graceful shutdowns.
+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 install `@push.rocks/smartexit`, use npm or Yarn as follows:
+To install `@push.rocks/smartexit`, use pnpm:
 
 ```bash
-npm install @push.rocks/smartexit --save
-```
-
-or
-
-```bash
-yarn add @push.rocks/smartexit
+pnpm install @push.rocks/smartexit
 ```
 
 ## Usage
 
-This library is designed to facilitate graceful shutdowns in Node.js applications by allowing developers to easily perform cleanup operations (like closing database connections or stopping child processes) before the process exits. Below is a guide on integrating `@push.rocks/smartexit` using TypeScript.
+`@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.
 
 ### Basic Setup
 
-First, import `SmartExit` from the package:
-
 ```typescript
 import { SmartExit } from '@push.rocks/smartexit';
-```
 
-Create an instance of `SmartExit`:
-
-```typescript
+// Create an instance - this automatically hooks into process signals
 const smartExit = new SmartExit();
 ```
 
 ### Registering Cleanup Functions
 
-`SmartExit` enables you to define custom cleanup functions that are executed before the process exits. These functions should return a promise to ensure all asynchronous cleanup operations complete successfully.
+Define custom async cleanup functions that execute before the process exits:
 
 ```typescript
 smartExit.addCleanupFunction(async () => {
-  console.log("Performing custom cleanup...");
-  // Your cleanup operations here
+  console.log('Closing database connections...');
+  await database.close();
+});
+
+smartExit.addCleanupFunction(async () => {
+  console.log('Flushing logs...');
+  await logger.flush();
 });
 ```
 
 ### Managing Child Processes
 
-It's common for a Node.js application to spawn child processes. `SmartExit` can also manage these, ensuring all child processes cleanly exit before the parent process exits.
-
-To add a child process to the management list:
+Track spawned child processes so they get properly terminated on exit:
 
 ```typescript
 import { spawn } from 'child_process';
 
-const childProcess = spawn('your_child_process');
+const childProcess = spawn('node', ['worker.js']);
 smartExit.addProcess(childProcess);
+
+// Remove from tracking if the process ends naturally
+childProcess.on('exit', () => {
+  smartExit.removeProcess(childProcess);
+});
 ```
 
-If necessary, you can remove a previously added child process:
+### Kill Process Trees by PID
+
+Terminate an entire process tree using the static `killTreeByPid` method:
 
 ```typescript
-smartExit.removeProcess(childProcess);
+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
+### Triggering Cleanup Manually
 
-`SmartExit` automatically hooks into several process signal events (like `SIGTERM` and `SIGINT`) to start the cleanup procedure. However, you can manually trigger the cleanup and exit processes:
+While `SmartExit` automatically hooks into `SIGINT`, `SIGTERM`, and uncaught exceptions, you can manually trigger cleanup:
 
 ```typescript
 await smartExit.killAll();
-process.exit(0); // or process.exit(1) to indicate an error state if needed
+process.exit(0);
 ```
 
-### Advanced Usage
+### Integrating with Express
 
-In more complex scenarios, you might need to conditionally add or remove cleanup functions and child processes, or integrate `SmartExit` with other libraries and frameworks for more comprehensive process management and shutdown procedures. Here you can leverage the full flexibility of JavaScript and TypeScript to tailor the shutdown behavior to your application's specific needs.
-
-#### Example: Shutdown on Uncaught Exceptions
+Gracefully close an Express server on shutdown:
 
 ```typescript
-process.on('uncaughtException', async (error) => {
-  console.error("Uncaught Exception:", error);
-  await smartExit.killAll(); // Ensures all cleanup functions and child processes are managed
-  process.exit(1); // Exits with error
-});
-```
+import express from 'express';
+import { SmartExit } from '@push.rocks/smartexit';
 
-#### Integrating with Express
+const app = express();
+const smartExit = new SmartExit();
 
-If your application uses Express, you might want to close the server gracefully:
-
-```typescript
-const server = app.listen(port, () => {
-  console.log(`Server started on port ${port}`);
+const server = app.listen(3000, () => {
+  console.log('Server running on port 3000');
 });
 
 smartExit.addCleanupFunction(async () => {
-  console.log("Closing Express server...");
-  await new Promise((resolve) => server.close(resolve));
+  console.log('Closing Express server...');
+  await new Promise<void>((resolve) => server.close(() => resolve()));
 });
 ```
 
----
+### Available Process Signals
 
-This documentation provides a foundational understanding of how to utilize `@push.rocks/smartexit` for managing graceful shutdowns in Node.js applications with TypeScript. Remember to adjust the code examples as necessary to fit your specific project requirements.
+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.23',
+  version: '1.1.1',
   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,161 @@
+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') {
+    const done = plugins.smartpromise.defer();
+    plugins.treeKill.default(pidArg, signalArg, (err) => {
+      if (err) {
+        done.reject(err);
+      } else {
+        done.resolve();
+      }
+    });
+    await done.promise;
+  }
+
+  // Instance state
+  public processesToEnd = new plugins.lik.ObjectMap<plugins.childProcess.ChildProcess>();
+  public cleanupFunctions = new plugins.lik.ObjectMap<() => Promise<any>>();
+  /** PIDs tracked independently — survives removeProcess() so shutdown can still kill the tree. */
+  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);
+  }
+
+  /**
+   * 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,10 +5,9 @@ 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';

tsconfig.json

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