v2.0.1

fix(core): track PIDs independently to survive removeProcess() race during shutdown
The direct child process may die from terminal SIGINT before ProcessLifecycle runs shutdown, causing removeProcess() to clear it. Now killAll() uses a persistent trackedPids Set that is never cleared by removeProcess(), ensuring grandchild process trees are always killed.
2026-03-03 23:56:58 +00:00 · 2026-03-03 23:56:52 +00:00 · 2026-03-03 23:40:24 +00:00 · 2026-03-03 23:40:05 +00:00 · 2026-03-03 22:34:01 +00:00 · 2026-03-03 22:34:01 +00:00
20 changed files with 8927 additions and 26064 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.gitea/workflows/default_nottags.yaml
@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
--- a/.gitea/workflows/default_tags.yaml
+++ b/.gitea/workflows/default_tags.yaml
@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,138 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/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
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-auditProductionDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --production --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=prod --production
-  tags:
-    - docker
-  allow_failure: true
-
-auditDevDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=dev
-  tags:
-    - docker
-  allow_failure: true
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-testBuild:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  only:
-    - tags
-  script:
-    - npmci command npm install -g tslint typescript
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install lts
-    - npmci command npm install -g @gitzone/tsdoc
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command tsdoc
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -2,28 +2,10 @@
  "version": "0.2.0",
  "configurations": [
    {
-      "name": "current file",
-      "type": "node",
+      "command": "npm test",
+      "name": "Run npm test",
      "request": "launch",
-      "args": [
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
+      "type": "node-terminal"
    }
  ]
 }
--- a/changelog.md
+++ b/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).
--- a/npmextra.json
+++ b/npmextra.json
@@ -2,17 +2,45 @@
  "gitzone": {
    "projectType": "npm",
    "module": {
-      "githost": "gitlab.com",
-      "gitscope": "pushrocks",
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
      "gitrepo": "smartexit",
-      "shortDescription": "do things before one exists a process",
-      "npmPackagename": "@pushrocks/smartexit",
+      "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"
+      "projectDomain": "push.rocks",
+      "keywords": [
+        "Node.js",
+        "TypeScript",
+        "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"
+      ]
    }
  },
  "npmci": {
    "npmGlobalTools": [],
    "npmAccessLevel": "public"
+  },
+  "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"
+    }
  }
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,29 +1,27 @@
 {
-  "name": "@pushrocks/smartexit",
-  "version": "1.0.16",
+  "name": "@push.rocks/smartexit",
+  "version": "2.0.1",
  "private": false,
-  "description": "do things before one exists a process",
+  "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",
  "license": "MIT",
  "scripts": {
    "test": "(tstest test/)",
-    "build": "(tsbuild)",
-    "format": "(gitzone format)"
+    "build": "(tsbuild --web)",
+    "buildDocs": "tsdoc"
  },
  "devDependencies": {
-    "@gitzone/tsbuild": "^2.0.22",
-    "@gitzone/tstest": "^1.0.15",
-    "@pushrocks/tapbundle": "^3.0.7",
-    "@types/node": "^16.4.3",
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.15.0"
+    "@git.zone/tsbuild": "^4.0.2",
+    "@git.zone/tsrun": "^2.0.1",
+    "@git.zone/tstest": "^3.1.3",
+    "@types/node": "^24.0.3"
  },
  "dependencies": {
-    "@pushrocks/lik": "^4.0.20",
-    "@pushrocks/smartdelay": "^2.0.3",
-    "@pushrocks/smartlog-source-ora": "^1.0.7"
+    "@push.rocks/lik": "^6.2.2",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "tree-kill": "^1.2.2"
  },
  "browserslist": [
    "last 1 chrome versions"
@@ -39,5 +37,27 @@
    "cli.js",
    "npmextra.json",
    "readme.md"
-  ]
+  ],
+  "type": "module",
+  "keywords": [
+    "Node.js",
+    "TypeScript",
+    "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"
+  }
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -0,0 +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();
+```
--- a/readme.md
+++ b/readme.md
@@ -1,38 +1,148 @@
-# @pushrocks/smartexit
-do things before one exists a process
+# @push.rocks/smartexit

-## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartexit)
-* [gitlab.com (source)](https://gitlab.com/pushrocks/smartexit)
-* [github.com (source mirror)](https://github.com/pushrocks/smartexit)
-* [docs (typedoc)](https://pushrocks.gitlab.io/smartexit/)
+A library for managing graceful shutdowns of Node.js processes by handling cleanup operations, including terminating child processes.

-## Status for master
+## Issue Reporting and Security

-Status Category | Status Badge
-- | --
-GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartexit/badges/master/pipeline.svg)](https://lossless.cloud)
-GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartexit/badges/master/coverage.svg)](https://lossless.cloud)
-npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartexit)](https://lossless.cloud)
-Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartexit)](https://lossless.cloud)
-TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
-node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
-PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartexit)](https://lossless.cloud)
-PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartexit)](https://lossless.cloud)
-BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartexit)](https://lossless.cloud)
-Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+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 pnpm:
+
+```bash
+pnpm install @push.rocks/smartexit
+```

 ## Usage

+`@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.

-## Contribution
+### Basic Setup

-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). :)
+```typescript
+import { SmartExit } from '@push.rocks/smartexit';

-For further information read the linked docs at the top of this readme.
+// Create an instance - this automatically hooks into process signals
+const smartExit = new SmartExit();
+```

-> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+### Registering Cleanup Functions

-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)
+Define custom async cleanup functions that execute before the process exits:
+
+```typescript
+smartExit.addCleanupFunction(async () => {
+  console.log('Closing database connections...');
+  await database.close();
+});
+
+smartExit.addCleanupFunction(async () => {
+  console.log('Flushing logs...');
+  await logger.flush();
+});
+```
+
+### Managing Child Processes
+
+Track spawned child processes so they get properly terminated on exit:
+
+```typescript
+import { spawn } from '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);
+});
+```
+
+### Kill Process Trees by PID
+
+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 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 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
+
+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.
--- a/test/test.ts
+++ b/test/test.ts
@@ -1,5 +1,5 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import * as smartexit from '../ts/index';
+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();
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartexit',
+  version: '1.1.1',
+  description: 'A library for managing graceful shutdowns of Node.js processes by handling cleanup operations, including terminating child processes.'
+}
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -1,84 +1,4 @@
-import * as plugins from './smartexit.plugins';
-
-import { ora } from './smartexit.logging';
-
-export class SmartExit {
-  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() {
-    ora.text('Checking for remaining child processes before exit...');
-    if (this.processesToEnd.getArray().length > 0) {
-      ora.text('found remaining child processes');
-      let counter = 1;
-      this.processesToEnd.forEach(async (childProcessArg) => {
-        const pid = childProcessArg.pid;
-        ora.text(`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 {
-      ora.text(`ChildProcesses look clean.`);
-    }
-    if (this.cleanupFunctions.getArray.length > 0) {
-      this.cleanupFunctions.forEach(async cleanupFunction => {
-        await cleanupFunction();
-      })
-    }
-    ora.text(`Ready to exit!`);
-  }
-
-  constructor() {
-    // do app specific cleaning before exiting
-    process.on('exit', async (code) => {
-      if (code === 0) {
-        ora.text('Process wants to exit');
-        await this.killAll();
-        ora.finishSuccess('Exited ok!');
-      } else {
-        ora.finishFail('Exited NOT OK!');
-      }
-    });
-
-    // catch ctrl+c event and exit normally
-    process.on('SIGINT', async () => {
-      ora.text('Ctrl-C... or SIGINT signal received!');
-      await this.killAll();
-      process.exit(0);
-    });
-
-    //catch uncaught exceptions, trace, then exit normally
-    process.on('uncaughtException', async (err) => {
-      ora.text('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';
--- a/ts/smartexit.classes.lifecycle.ts
+++ b/ts/smartexit.classes.lifecycle.ts
@@ -0,0 +1,210 @@
+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 PIDs. */
+  private handleExit(): void {
+    const instances = ProcessLifecycle.getInstances();
+    let killed = 0;
+
+    for (const instance of instances) {
+      for (const pid of instance.trackedPids) {
+        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`);
+    }
+  }
+}
--- a/ts/smartexit.classes.smartexit.ts
+++ b/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);
+  }
+}
--- a/ts/smartexit.logging.ts
+++ b/ts/smartexit.logging.ts
@@ -1,3 +0,0 @@
-import * as plugins from './smartexit.plugins';
-
-export const ora = new plugins.smartlogSourceOra.SmartlogSourceOra();
--- a/ts/smartexit.plugins.ts
+++ b/ts/smartexit.plugins.ts
@@ -4,8 +4,14 @@ import * as childProcess from 'child_process';
 export { childProcess };

 // pushrocks scope
-import * as lik from '@pushrocks/lik';
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartlogSourceOra from '@pushrocks/smartlog-source-ora';
+import * as lik from '@push.rocks/lik';
+import * as smartpromise from '@push.rocks/smartpromise';

-export { lik, smartdelay, smartlogSourceOra };
+export { lik, smartpromise };
+
+// third party scope
+import * as treeKill from 'tree-kill';
+
+export {
+  treeKill
+}
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}
--- a/tslint.json
+++ b/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"
-}
Author	SHA1	Message	Date
Juergen Kunz	a623ac5fe4	v2.0.1	2026-03-03 23:56:58 +00:00
Juergen Kunz	34b9aa4463	fix(core): track PIDs independently to survive removeProcess() race during shutdown The direct child process may die from terminal SIGINT before ProcessLifecycle runs shutdown, causing removeProcess() to clear it. Now killAll() uses a persistent trackedPids Set that is never cleared by removeProcess(), ensuring grandchild process trees are always killed.	2026-03-03 23:56:52 +00:00
Juergen Kunz	da24218bef	v2.0.0	2026-03-03 23:40:24 +00:00
Juergen Kunz	862c67edbb	BREAKING CHANGE(lifecycle): redesign SmartExit with ProcessLifecycle singleton SmartExit constructor no longer installs signal handlers. Applications must call ProcessLifecycle.install() explicitly. Split into SmartExit (instance process tracking) and ProcessLifecycle (global signal coordination). Remove @push.rocks/smartdelay dependency.	2026-03-03 23:40:05 +00:00
Juergen Kunz	ad8e389ef5	v1.1.1	2026-03-03 22:34:01 +00:00
Juergen Kunz	1986b3a421	fix(shutdown): kill full child process trees and add synchronous exit handler to force-kill remaining child processes	2026-03-03 22:34:01 +00:00
Juergen Kunz	2e5b26c9cf	v1.1.0	2025-12-15 16:58:01 +00:00
Juergen Kunz	bb2831ec0f	feat(smartexit): Add silent logging option, structured shutdown logs, and killAll return stats	2025-12-15 16:58:01 +00:00
Juergen Kunz	4ce60859e4	v1.0.24	2025-12-15 15:58:52 +00:00
Juergen Kunz	207ebd0e07	fix(deps): bump dependencies, update tests and docs, adjust tsconfig and npm release config	2025-12-15 15:58:52 +00:00
Philipp Kunz	fc4238f0fc	update description	2024-05-29 14:12:57 +02:00
Philipp Kunz	1dbb6f6a7c	1.0.23	2024-04-18 13:36:10 +02:00
Philipp Kunz	13f556abe5	fix(core): update	2024-04-18 13:36:09 +02:00
Philipp Kunz	d3fe10d282	1.0.22	2024-04-18 13:26:03 +02:00
Philipp Kunz	fd6eb7eecf	fix(core): update	2024-04-18 13:26:02 +02:00
Philipp Kunz	3d1ad808a5	update tsconfig	2024-04-14 17:33:39 +02:00
Philipp Kunz	7ef3a8da22	update npmextra.json: githost	2024-04-01 21:34:53 +02:00
Philipp Kunz	35871b6f23	update npmextra.json: githost	2024-04-01 19:58:10 +02:00
Philipp Kunz	ce3eda10e8	update npmextra.json: githost	2024-03-30 21:47:08 +01:00
Philipp Kunz	c1de38b771	1.0.21	2023-09-11 10:29:02 +02:00
Philipp Kunz	1588c695ce	fix(core): update	2023-09-11 10:29:01 +02:00
Philipp Kunz	8192cb7bf9	switch to new org scheme	2023-07-10 02:49:01 +02:00
Philipp Kunz	2031a408bf	1.0.20	2021-08-17 18:12:29 +02:00
Philipp Kunz	a2b3cede4e	fix(core): update	2021-08-17 18:12:28 +02:00
Philipp Kunz	ac51ece229	1.0.19	2021-07-27 15:08:45 +02:00
Philipp Kunz	49c4681b87	fix(core): update	2021-07-27 15:08:44 +02:00
Philipp Kunz	9cae8d4818	1.0.18	2021-07-27 14:56:02 +02:00
Philipp Kunz	ecc8b1c73a	fix(core): update	2021-07-27 14:56:02 +02:00
Philipp Kunz	cbc4b7b285	1.0.17	2021-07-27 13:55:48 +02:00
Philipp Kunz	6210358568	fix(core): update	2021-07-27 13:55:47 +02:00