3.0.62

fix(Service Worker): Refactor and clean up the cache logic in the Service Worker to improve maintainability and handle Safari-specific cache behavior.
3.0.61
2025-02-04 01:52:48 +01:00 · 2025-02-04 01:52:48 +01:00 · 2025-02-04 01:45:09 +01:00 · 2025-02-04 01:45:08 +01:00 · 2025-02-04 01:36:36 +01:00 · 2025-02-04 01:36:35 +01:00
89 changed files with 11020 additions and 4034 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,128 +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
-
-before_script:
-  - pnpm install -g pnpm
-  - pnpm install -g @shipzone/npmci
-  - npmci npm prepare
-
-# ====================
-# security stage
-# ====================
-# ====================
-# security stage
-# ====================
-auditProductionDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-     - npmci command npm config set registry https://registry.npmjs.org
-     - npmci command pnpm audit --audit-level=high --prod
-  tags:
-    - lossless
-    - docker
-  allow_failure: true
-
-auditDevDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command pnpm audit --audit-level=high --dev
-  tags:
-    - lossless
-    - docker
-  allow_failure: true
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-testBuild:
-  stage: test
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm 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 typescript
-    - npmci npm prepare
-    - npmci npm install
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run buildDocs
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true
--- a/changelog.md
+++ b/changelog.md
@ -0,0 +1,253 @@
+# Changelog
+
+## 2025-02-04 - 3.0.62 - fix(Service Worker)
+Refactor and clean up the cache logic in the Service Worker to improve maintainability and handle Safari-specific cache behavior.
+
+- Refactored logic for determining cached domains, enhancing the readability and maintainability of the code.
+- Improved handling of CORS settings in caching requests, notably bypassing caching for soft cached domains in Safari to avoid CORS issues.
+- Enhanced error response creation for failed resource fetching, maintaining clarity on why and how certain resources were not fetched or cached.
+- Revised the structure of the caching logic to ensure consistent behavior across all supported browsers.
+
+## 2025-02-04 - 3.0.61 - fix(ServiceWorkerCacheManager)
+Fixed caching mechanism to better support Safari's handling of soft-cached domains.
+
+- Added logic to differentiate between hard and soft cached domains.
+- Implemented special handling for soft cached domains on Safari by bypassing caching.
+- Ensured appropriate CORS headers are present in cached responses.
+- Improved error handling with informative 500 error responses.
+- Optimized caching logic to prevent redundant caching and potential issues with locked streams on Safari.
+
+## 2025-02-04 - 3.0.61 - fix(ServiceWorkerCacheManager)
+Fixed caching mechanism to better support Safari's handling of soft-cached domains.
+
+- Added logic to differentiate between hard and soft cached domains.
+- Implemented special handling for soft cached domains on Safari by bypassing caching.
+- Ensured appropriate CORS headers are present in cached responses.
+- Improved error handling with informative 500 error responses.
+- Optimized caching logic to prevent redundant caching and potential issues with locked streams on Safari.
+
+## 2025-02-04 - 3.0.61 - fix(ServiceWorkerCacheManager)
+Fixed caching mechanism to better support Safari's handling of soft-cached domains.
+
+- Added logic to differentiate between hard and soft cached domains.
+- Implemented special handling for soft cached domains on Safari by bypassing caching.
+- Ensured appropriate CORS headers are present in cached responses.
+- Improved error handling with informative 500 error responses.
+- Optimized caching logic to prevent redundant caching and potential issues with locked streams on Safari.
+
+## 2025-02-04 - 3.0.60 - fix(cachemanager)
+Improve cache management and error handling
+
+- Updated comments for clarity and consistency.
+- Enhanced error handling in `fetch` event listener.
+- Optimized cache key management and cleanup process.
+- Ensured CORS headers are set for cached responses.
+- Improved logging for caching operations.
+
+## 2025-02-03 - 3.0.59 - fix(serviceworker)
+Fixed CORS and Cache Control handling for Service Worker
+
+- Improved handling of CORS settings for external requests.
+- Preserved important headers while excluding caching headers.
+- Ensured the presence of CORS headers in cached responses.
+- Adjusted Cache-Control headers to prevent browser caching but allow service worker caching.
+
+## 2025-02-03 - 3.0.58 - fix(network-manager)
+Refined network management logic for better offline handling.
+
+- Improved logic to handle missing connections more gracefully.
+- Added detailed online/offline connection status logging.
+- Implemented a check for stale cache with a grace period for offline scenarios.
+- Network requests now use optimized retries and timeouts.
+
+## 2025-02-03 - 3.0.57 - fix(updateManager)
+Refine cache management for service worker updates.
+
+- Ensured cache is forcibly updated if older than defined maximum age.
+- Implemented interval checks and forced updates for cache staleness.
+- Updated version information and cache timestamps upon forced updates or validations.
+
+## 2025-02-03 - 3.0.56 - fix(cachemanager)
+Adjust cache control headers and fix redundant code
+
+- Remove duplicate assetbroker URLs in the cache evaluation logic.
+- Update cache control headers to improve caching behavior.
+- Increase the timeout for fetch operations to improve compatibility.
+
+## 2025-01-28 - 3.0.55 - fix(server)
+Fix response content manipulation for HTML files with injectReload
+
+- Moved fileString declaration inside HTML file handling block to prevent unnecessary string conversion for non-HTML files.
+- Corrected responseContent assignment to ensure modified HTML strings are converted back to Buffer format.
+
+## 2025-01-28 - 3.0.54 - fix(servertools)
+Fixed an issue with compression results handling in HandlerStatic where content was always being written even if not compressed.
+
+- Corrected the double writing of response in HandlerStatic.
+- Ensured that file buffers are only conditionally written based on compression availability.
+
+## 2024-12-26 - 3.0.53 - fix(infohtml)
+Remove Sentry script and logo from HTML template
+
+- Removed Sentry script from the HTML template.
+- Removed Lossless GmbH logo and contact info.
+- Updated footer link to point to foss.global.
+
+## 2024-12-25 - 3.0.52 - fix(dependencies)
+Bump package versions in dependencies and exports.
+
+- Updated package dependencies to their latest versions.
+- Added './infohtml' in package exports.
+
+## 2024-08-27 - 3.0.51 - fix(core)
+Update dependencies and fix service worker cache manager and task manager functionalities
+
+- Updated dependencies in package.json to their latest versions
+- Enhanced service worker cache manager to include additional scoped URLs
+- Fixed task manager to start the task manager and added update task functionality
+- Removed .gitlab-ci.yml from the repository as part of the cleanup
+
+## 2024-05-25 - 3.0.43 to 3.0.50 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.43 to 3.0.50
+
+## 2024-05-23 - 3.0.37 to 3.0.42 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.37 to 3.0.42
+
+## 2024-05-17 - 3.0.37 - Core
+Routine update and bug fix
+
+- Updated core functionalities
+
+## 2024-05-14 - 3.0.33 to 3.0.36 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.33 to 3.0.36
+
+## 2024-05-13 - 3.0.31 to 3.0.32 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.31 to 3.0.32
+
+## 2024-05-11 - 3.0.29 to 3.0.31 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.29 to 3.0.31
+
+## 2024-04-19 - 3.0.27 to 3.0.28 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.27 to 3.0.28
+
+## 2024-04-14 - 3.0.27 - Documentation
+Updated Documentation
+
+- Improved and updated documentation
+
+## 2024-03-01 - 3.0.25 to 3.0.26 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.25 to 3.0.26
+
+## 2024-02-21 - 3.0.20 to 3.0.24 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.20 to 3.0.24
+
+## 2024-01-19 - 3.0.19 to 3.0.20 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.19 to 3.0.20
+
+## 2024-01-09 - 3.0.14 to 3.0.18 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.14 to 3.0.18
+
+## 2024-01-08 - 3.0.11 to 3.0.13 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.11 to 3.0.13
+
+## 2024-01-07 - 3.0.9 to 3.0.10 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.9 to 3.0.10
+
+## 2023-11-06 - 3.0.8 to 3.0.9 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.8 to 3.0.9
+
+## 2023-10-23 - 3.0.6 to 3.0.7 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.6 to 3.0.7
+
+## 2023-10-20 - 3.0.5 to 3.0.6 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.5 to 3.0.6
+
+## 2023-09-21 - 3.0.4 to 3.0.5 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.4 to 3.0.5
+
+## 2023-08-06 - 3.0.2 to 3.0.3 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.2 to 3.0.3
+
+## 2023-08-03 - 3.0.1 to 3.0.0 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.1 to 3.0.0
+
+## 2023-08-03 - 2.0.65 - Core
+Breaking change in core update
+
+- Introduced breaking changes updating core functionalities
+
+## 2023-07-02 - 2.0.59 to 2.0.64 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.59 to 2.0.64
+
+## 2023-07-01 - 2.0.54 to 2.0.58 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.54 to 2.0.58
+
+## 2023-06-12 - 2.0.53 - Core
+Routine update and bug fix
+
+- Updated core functionalities
+
+## 2023-04-10 - 2.0.52 to 2.0.53 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.52 to 2.0.53
+
+## 2023-04-04 - 2.0.49 to 2.0.51 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.49 to 2.0.51
+
+## 2023-03-31 - 2.0.45 to 2.0.48 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.45 to 2.0.48
+
+## 2023-03-30 - 2.0.37 to 2.0.44 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.37 to 2.0.44
+
+## 2023-03-29 - 2.0.33 to 2.0.36 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.33 to 2.0.36
--- a/npmextra.json
+++ b/npmextra.json
@ -5,12 +5,31 @@
  "gitzone": {
    "projectType": "npm",
    "module": {
-      "githost": "gitlab.com",
+      "githost": "code.foss.global",
      "gitscope": "pushrocks",
      "gitrepo": "typedserver",
-      "description": "easy serving of static files",
+      "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
      "npmPackagename": "@api.global/typedserver",
-      "license": "MIT"
+      "license": "MIT",
+      "keywords": [
+        "TypeScript",
+        "static file serving",
+        "live reload",
+        "compression",
+        "typed requests",
+        "HTTP server",
+        "SSL",
+        "cors",
+        "express middleware",
+        "proxy",
+        "sitemap",
+        "feeds",
+        "robots.txt",
+        "compression (gzip, deflate, brotli)"
+      ]
    }
+  },
+  "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"
  }
 }
--- a/package.json
+++ b/package.json
@ -1,22 +1,43 @@
 {
  "name": "@api.global/typedserver",
-  "version": "3.0.22",
-  "description": "easy serving of static files",
-  "main": "dist_ts/index.js",
-  "typings": "dist_ts/index.d.ts",
+  "version": "3.0.62",
+  "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
  "type": "module",
+  "exports": {
+    ".": "./dist_ts/index.js",
+    "./infohtml": "./dist_ts/infohtml/index.js",
+    "./backend": "./dist_ts/index.js",
+    "./edgeworker": "./dist_ts_edgeworker/index.js",
+    "./web_inject": "./dist_ts_web_inject/index.js",
+    "./web_serviceworker": "./dist_ts_web_serviceworker/index.js",
+    "./web_serviceworker_client": "./dist_ts_web_serviceworker_client/index.js"
+  },
  "scripts": {
    "test": "npm run build && tstest test/",
-    "build": "tsbuild --web --allowimplicitany && tsbundle --from ./ts_web/index.ts --to ./dist_ts_web/bundle.js",
-    "buildDocs": "tsdoc"
+    "build": "tsbuild tsfolders --web --allowimplicitany && npm run bundle",
+    "bundle": "tsbundle --from ./ts_web_inject/index.ts --to ./dist_ts_web_inject/bundle.js && tsbundle --from ./ts_web_serviceworker/index.ts --to ./dist_ts_web_serviceworker/serviceworker.bundle.js",
+    "interfaces": "tsbuild interfaces --web --allowimplicitany --skiplibcheck",
+    "docs": "tsdoc aidoc"
  },
  "repository": {
    "type": "git",
    "url": "https://github.com/pushrocks/easyserve.git"
  },
  "keywords": [
-    "serve",
-    "browser-sync"
+    "TypeScript",
+    "static file serving",
+    "live reload",
+    "compression",
+    "typed requests",
+    "HTTP server",
+    "SSL",
+    "cors",
+    "express middleware",
+    "proxy",
+    "sitemap",
+    "feeds",
+    "robots.txt",
+    "compression (gzip, deflate, brotli)"
  ],
  "author": "Lossless GmbH <office@lossless.com> (https://lossless.com)",
  "license": "MIT",
@ -37,44 +58,51 @@
  ],
  "homepage": "https://github.com/pushrocks/easyserve",
  "dependencies": {
-    "@api.global/typedrequest": "^3.0.4",
-    "@api.global/typedrequest-interfaces": "^3.0.2",
-    "@api.global/typedsocket": "^3.0.0",
-    "@push.rocks/lik": "^6.0.12",
-    "@push.rocks/smartchok": "^1.0.32",
+    "@api.global/typedrequest": "^3.1.10",
+    "@api.global/typedrequest-interfaces": "^3.0.19",
+    "@api.global/typedsocket": "^3.0.1",
+    "@cloudflare/workers-types": "^4.20241224.0",
+    "@design.estate/dees-comms": "^1.0.27",
+    "@push.rocks/lik": "^6.1.0",
+    "@push.rocks/smartchok": "^1.0.34",
    "@push.rocks/smartdelay": "^3.0.5",
    "@push.rocks/smartenv": "^5.0.12",
    "@push.rocks/smartfeed": "^1.0.11",
-    "@push.rocks/smartfile": "^11.0.4",
-    "@push.rocks/smartjson": "^5.0.10",
-    "@push.rocks/smartlog": "^3.0.3",
-    "@push.rocks/smartlog-destination-devtools": "^1.0.10",
+    "@push.rocks/smartfile": "^11.0.23",
+    "@push.rocks/smartjson": "^5.0.20",
+    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartlog-destination-devtools": "^1.0.12",
+    "@push.rocks/smartlog-interfaces": "^3.0.2",
    "@push.rocks/smartmanifest": "^2.0.2",
-    "@push.rocks/smartmime": "^1.0.5",
+    "@push.rocks/smartmatch": "^2.0.0",
+    "@push.rocks/smartmime": "^2.0.4",
+    "@push.rocks/smartntml": "^2.0.8",
    "@push.rocks/smartopen": "^2.0.0",
-    "@push.rocks/smartpath": "^5.0.11",
-    "@push.rocks/smartpromise": "^4.0.2",
-    "@push.rocks/smartrequest": "^2.0.21",
+    "@push.rocks/smartpath": "^5.0.18",
+    "@push.rocks/smartpromise": "^4.0.4",
+    "@push.rocks/smartrequest": "^2.0.23",
    "@push.rocks/smartrx": "^3.0.7",
    "@push.rocks/smartsitemap": "^2.0.3",
-    "@push.rocks/smartstream": "^3.0.30",
-    "@push.rocks/smarttime": "^4.0.6",
-    "@push.rocks/webstore": "^2.0.13",
-    "@tsclass/tsclass": "^4.0.52",
+    "@push.rocks/smartstream": "^3.2.5",
+    "@push.rocks/smarttime": "^4.1.1",
+    "@push.rocks/taskbuffer": "^3.1.7",
+    "@push.rocks/webrequest": "^3.0.37",
+    "@push.rocks/webstore": "^2.0.20",
+    "@tsclass/tsclass": "^4.2.0",
    "@types/express": "^4.17.21",
-    "body-parser": "^1.20.2",
+    "body-parser": "^1.20.3",
    "cors": "^2.8.5",
-    "express": "^4.18.2",
+    "express": "^4.21.2",
    "express-force-ssl": "^0.3.2",
-    "lit": "^3.1.2"
+    "lit": "^3.2.1"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.72",
-    "@git.zone/tsbundle": "^2.0.15",
-    "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^1.0.86",
-    "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.11.19"
+    "@git.zone/tsbuild": "^2.2.0",
+    "@git.zone/tsbundle": "^2.1.0",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^1.0.90",
+    "@push.rocks/tapbundle": "^5.5.3",
+    "@types/node": "^22.10.2"
  },
  "private": false,
  "browserslist": [
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.hints.md
+++ b/readme.hints.md
@ -0,0 +1 @@
+ 
--- a/readme.md
+++ b/readme.md
@ -1,49 +1,133 @@
-# @pushrocks/typedserver
-easy serving of static files
+```markdown
+# @api.global/typedserver
+Easy serving of static files

-## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@apiglobal/typedserver)
-* [gitlab.com (source)](https://gitlab.com/pushrocks/typedserver)
-* [github.com (source mirror)](https://github.com/pushrocks/typedserver)
-* [docs (typedoc)](https://pushrocks.gitlab.io/typedserver/)
+## Install
+To install @api.global/typedserver, run the following command in your terminal:

-## Status for master
+```bash
+npm install @api.global/typedserver --save
+```

-Status Category | Status Badge
-- | --
-GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/typedserver/badges/master/pipeline.svg)](https://lossless.cloud)
-GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/typedserver/badges/master/coverage.svg)](https://lossless.cloud)
-npm | [![npm downloads per month](https://badgen.net/npm/dy/@apiglobal/typedserver)](https://lossless.cloud)
-Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/typedserver)](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/@apiglobal/typedserver)](https://lossless.cloud)
-PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@apiglobal/typedserver)](https://lossless.cloud)
-BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@apiglobal/typedserver)](https://lossless.cloud)
+This will add `@api.global/typedserver` to your project's dependencies.

 ## Usage

-Use TypeScript for best in class instellisense.
+`@api.global/typedserver` is designed to make serving static files and handling web requests in a TypeScript environment easy and efficient. It leverages Express under the hood, providing a powerful API for web server creation with additional utilities for live reloading, typed requests/responses, and more, embracing TypeScript's static typing advantages.

-```javascript
-import { TypedServer } from '@apiglobal/typedserver';
+### Setting up a Basic Web Server

-let myTypedserver = new TypedServer('/some/path/to/webroot', 8080);
-myTypedserver.start().then(() => {
-  // this is executed when server is running guaranteed
-  myTypedserver.stop(); // .stop() will work even if not waiting for server to be fully started
-});
+The following example demonstrates how to set up a basic web server serving files from a directory.

-myTypedserver.reload(); // reloads all connected browsers of this instance
+```typescript
+import { TypedServer } from '@api.global/typedserver';
+
+const serverOptions = {
+  port: 8080, // Port to listen on
+  serveDir: 'public', // Directory to serve static files from
+  watch: true, // Enable live reloading of changes
+  injectReload: true, // Inject live reload script into served HTML files
+  cors: true // Enable CORS
+};
+
+const typedServer = new TypedServer(serverOptions);
+
+async function startServer() {
+  await typedServer.start();
+  console.log(`Server is running on http://localhost:${serverOptions.port}`);
+}
+
+startServer().catch(console.error);
 ```

-## Contribution
+In the example above, `TypedServer` is instantiated with an `IServerOptions` object specifying options like the port to listen on (`8080`), the directory containing static files to serve (`public`), and live reload features. Calling `start()` on the `typedServer` instance initiates the server.

-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). :)
+### Using Typed Requests and Responses

-For further information read the linked docs at the top of this readme.
+`TypedServer` supports typed requests and responses, making API development more robust and maintainable. Define your request and response types, and use them to type-check incoming requests and their responses.

-## Legal
-> MIT licensed | **&copy;** [Task Venture Capital GmbH](https://task.vc)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+First, define the types:
+
+```typescript
+// Define a request type
+interface MyCustomRequest {
+  userId: string;
+}
+
+// Define a response type
+interface MyCustomResponse {
+  userName: string;
+}
+```
+
+Next, set up a route to handle requests using these types:
+
+```typescript
+import { TypedRouter, TypedHandler } from '@api.global/typedrequest';
+
+// Instantiate a TypedRouter
+const typedRouter = new TypedRouter();
+
+// Register a route with request and response types
+typedRouter.addTypedHandler<MyCustomRequest, MyCustomResponse>(
+  new TypedHandler('getUser', async (requestData) => {
+    // Implement your logic here. For example, fetch user data from a database.
+    const userData = { userName: 'John Doe' }; // Dummy implementation
+    return { response: userData };
+  })
+);
+
+// Bind the typed router to the server
+typedServer.useTypedRouter(typedRouter);
+
+// Now, the route is set up to handle requests with type checking
+```
+
+This example shows defining types for requests and responses, creating a `TypedRouter`, and adding a route with typed handling. This feature brings the benefits of TypeScript's static type checking to server-side logic, improving the development experience.
+
+### Enabling SSL/TLS
+
+To enable SSL/TLS, configure the `TypedServer` with the SSL options, including the paths to your SSL certificate and key files:
+
+```typescript
+const serverOptions = {
+  port: 443,
+  serveDir: 'public',
+  watch: true,
+  injectReload: true,
+  cors: true,
+  privateKey: fs.readFileSync('path/to/ssl/private.key'),
+  publicKey: fs.readFileSync('path/to/ssl/certificate.crt')
+};
+
+const typedServer = new TypedServer(serverOptions);
+startServer().catch(console.error);
+```
+
+Replace `'path/to/ssl/private.key'` and `'path/to/ssl/certificate.crt'` with the actual paths to your SSL key and certificate files. This setup ensures that your server communicates over HTTPS, encrypting the data transmitted between the client and the server.
+
+### Conclusion
+
+`@api.global/typedserver` offers a streamlined way to set up a web server with TypeScript, featuring static file serving, live reloading, typed request/response handling, and SSL support. This guide covers the basic usage, but `TypedServer` is highly configurable, catering to various hosting and development needs.
+```
+
+For a deeper dive into the API and more advanced configurations, refer to the official documentation and type definitions included in the package.
+
+## 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. 
+
+**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.
+
+### Company Information
+
+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.
+
+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/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
 */
 export const commitinfo = {
  name: '@api.global/typedserver',
-  version: '3.0.22',
-  description: 'easy serving of static files'
+  version: '3.0.62',
+  description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }
--- a/ts/typedserver.classes.typedserver.ts
+++ b/ts/typedserver.classes.typedserver.ts
@ -1,6 +1,6 @@
 import * as plugins from './plugins.js';
-import * as paths from './typedserver.paths.js';
-import * as interfaces from './interfaces/index.js';
+import * as paths from './paths.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
 import * as servertools from './servertools/index.js';
 import { type TCompressionMethod } from './servertools/classes.compressor.js';

@ -103,7 +103,7 @@ export class TypedServer {
          case 'devtools':
            res.setHeader('Content-Type', 'text/javascript');
            res.status(200);
-            res.write(plugins.smartfile.fs.toStringSync(paths.bundlePath));
+            res.write(plugins.smartfile.fs.toStringSync(paths.injectBundlePath));
            res.end();
            break;
          case 'reloadcheck':
@ -135,8 +135,8 @@ export class TypedServer {
        '/*',
        new servertools.HandlerStatic(this.options.serveDir, {
          responseModifier: async (responseArg) => {
-            let fileString = responseArg.responseContent.toString();
            if (plugins.path.parse(responseArg.path).ext === '.html') {
+              let fileString = responseArg.responseContent.toString();
              const fileStringArray = fileString.split('<head>');
              if (this.options.injectReload && fileStringArray.length === 2) {
                fileStringArray[0] = `${fileStringArray[0]}<head>
@ -152,6 +152,7 @@ export class TypedServer {
                `;
                fileString = fileStringArray.join('');
                console.log('injected typedserver script.');
+                responseArg.responseContent = Buffer.from(fileString);
              } else if (this.options.injectReload) {
                console.log('Could not insert typedserver script');
              }
@ -164,7 +165,7 @@ export class TypedServer {
            return {
              headers,
              path: responseArg.path,
-              responseContent: Buffer.from(fileString),
+              responseContent: responseArg.responseContent,
            };
          },
          serveIndexHtmlDefault: true,
--- a/ts/index.ts
+++ b/ts/index.ts
@ -4,7 +4,12 @@ import * as servertools from './servertools/index.js';

 export { servertools };

-export * from './typedserver.classes.typedserver.js';
+export * from './classes.typedserver.js';
 // Type helpers
 export type Request = plugins.express.Request;
 export type Response = plugins.express.Response;
+
+
+// lets export utilityservers
+import * as utilityservers from './utilityservers/index.js';
+export { utilityservers };
--- a/ts/infohtml/00_commitinfo_data.ts
+++ b/ts/infohtml/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@losslessone_private/lole-infohtml',
+  version: '1.0.39',
+  description: 'html for displaying infos at lossless'
+}
--- a/ts/infohtml/index.ts
+++ b/ts/infohtml/index.ts
@ -0,0 +1,44 @@
+import * as plugins from './infohtml.plugins.js';
+
+import { simpleInfo } from './template.js';
+
+export interface IHtmlInfoOptions {
+  text: string;
+  heading?: string;
+  title?: string;
+  sentryMessage?: string;
+  sentryDsn?: string;
+  redirectTo?: string;
+}
+
+export class InfoHtml {
+  // STATIC
+  public static async fromSimpleText(textArg: string) {
+    const infohtmlInstance = new InfoHtml({
+      text: textArg,
+      heading: null,
+    });
+    await infohtmlInstance.init();
+    return infohtmlInstance;
+  }
+
+  public static async fromOptions(optionsArg: IHtmlInfoOptions) {
+    const infohtmlInstance = new InfoHtml(optionsArg);
+    await infohtmlInstance.init();
+    return infohtmlInstance;
+  }
+
+  // INSTANCE
+  public options: IHtmlInfoOptions;
+  public smartntmlInstance: plugins.smartntml.Smartntml;
+  public htmlString: string;
+  constructor(optionsArg: IHtmlInfoOptions) {
+    this.options = optionsArg;
+  }
+
+  public async init() {
+    this.smartntmlInstance = new plugins.smartntml.Smartntml();
+    this.htmlString = await simpleInfo(this.smartntmlInstance, this.options);
+    return this.htmlString;
+  }
+}
--- a/ts/infohtml/infohtml.plugins.ts
+++ b/ts/infohtml/infohtml.plugins.ts
@ -0,0 +1,3 @@
+import * as smartntml from '@push.rocks/smartntml';
+
+export { smartntml };
--- a/ts/infohtml/template.ts
+++ b/ts/infohtml/template.ts
@ -0,0 +1,132 @@
+import * as plugins from './infohtml.plugins.js';
+import { type IHtmlInfoOptions } from './index.js';
+
+export const simpleInfo = async (
+  smartntmlInstanceArg: plugins.smartntml.Smartntml,
+  optionsArg: IHtmlInfoOptions
+) => {
+  const html = plugins.smartntml.deesElement.html;
+  const htmlTemplate = await plugins.smartntml.deesElement.html`
+    <html lang="en">
+      <head>
+        <title>${optionsArg.title}</title>
+        <script>
+          setTimeout(() => {
+            const redirectUrl = '${optionsArg.redirectTo}';
+            if (redirectUrl) {
+              window.location = redirectUrl;
+            }
+          }, 5000);
+        </script>
+        <style>
+          body {
+            margin: 0px;
+            background: #000000;
+            font-family: 'Roboto Mono', monospace;
+            min-height: 100vh;
+            min-width: 100vw;
+            border: 1px solid #e4002b;
+          }
+
+          * {
+            box-sizing: border-box;
+          }
+
+          .logo {
+            width: 150px;
+            padding-top: 70px;
+            margin: 0px auto 30px auto;
+          }
+
+          .content {
+            text-align: center;
+            max-width: 800px;
+            margin: auto;
+          }
+
+          .content .maintext {
+            margin: 10px;
+            color: #ffffff;
+            background: #333;
+            display: block;
+            border-radius: 3px;
+            box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.3);
+            padding: 20px;
+          }
+
+          .content .maintext h1 {
+            margin: 0px;
+          }
+
+          .content .addontext {
+            margin: 10px;
+            color: #ffffff;
+            background: #222;
+            display: block;
+            padding: 10px 15px;
+            border-radius: 3px;
+            box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.3);
+            padding: 10px;
+          }
+
+          .content .text h1 {
+            margin: 0px;
+            font-weight: 100;
+            font-size: 40px;
+          }
+
+          .content .text ul {
+            text-align: left;
+          }
+
+          a {
+            color: #ffffff;
+          }
+
+          .legal {
+            color: #fff;
+            position: fixed;
+            bottom: 0px;
+            width: 100vw;
+            text-align: center;
+            padding: 10px;
+          }
+        </style>
+        <meta
+          name="viewport"
+          content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width, height=device-height, target-densitydpi=device-dpi"
+        />
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+      </head>
+      <body>
+        <div class="content">
+          ${(() => {
+            const returnArray: plugins.smartntml.deesElement.TemplateResult[] = [];
+            if (optionsArg.heading) {
+              returnArray.push(html`
+                <div class="maintext">
+                  <h1>${optionsArg.heading}</h1>
+                  ${optionsArg.text}
+                </div>
+              `);
+            } else {
+              returnArray.push(html` <div class="maintext">${optionsArg.text}</div> `);
+            }
+            if (optionsArg.redirectTo) {
+              returnArray.push(
+                html`<div class="addontext">
+                  We will redirect you to ${optionsArg.redirectTo} in a few seconds.
+                </div>`
+              );
+            }
+            return returnArray;
+          })()}
+        </div>
+        <div class="legal">
+          <a href="https://foss.global">learn more about foss.global</a> / &copy 2014-${new Date().getFullYear()} Task Venture Capital GmbH
+        </div>
+      </body>
+    </html>
+  `;
+  return smartntmlInstanceArg.renderTemplateResult(htmlTemplate);
+};
--- a/ts/paths.ts
+++ b/ts/paths.ts
@ -0,0 +1,11 @@
+import * as plugins from './plugins.js';
+
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);
+
+export const injectBundleDir = plugins.path.join(packageDir, './dist_ts_web_inject');
+export const injectBundlePath = plugins.path.join(injectBundleDir, './bundle.js');
+
+export const serviceworkerBundleDir = plugins.path.join(packageDir, './dist_ts_web_serviceworker');
--- a/ts/servertools/classes.handlerproxy.ts
+++ b/ts/servertools/classes.handlerproxy.ts
@ -1,7 +1,7 @@
 import * as plugins from '../plugins.js';
 import { Handler } from './classes.handler.js';

-import * as interfaces from '../interfaces/index.js';
+import * as interfaces from '../../dist_ts_interfaces/index.js';

 export class HandlerProxy extends Handler {
  /**
--- a/ts/servertools/classes.handlerstatic.ts
+++ b/ts/servertools/classes.handlerstatic.ts
@ -1,5 +1,5 @@
 import * as plugins from '../plugins.js';
-import * as interfaces from '../interfaces/index.js';
+import * as interfaces from '../../dist_ts_interfaces/index.js';

 import { Handler } from './classes.handler.js';
 import { Compressor, type TCompressionMethod, type ICompressionResult } from './classes.compressor.js';
@ -134,8 +134,10 @@ export class HandlerStatic extends Handler {
      res.status(200);
      if (compressionResult?.compressionMethod) {
        res.header('Content-Encoding', compressionResult.compressionMethod);
+        res.write(compressionResult.result);
+      } else {
+        res.write(fileBuffer);
      }
-      res.write(compressionResult.result);
      res.end();
    });
  }
--- a/ts/servertools/classes.handlertypedrouter.ts
+++ b/ts/servertools/classes.handlertypedrouter.ts
@ -1,7 +1,7 @@
 import * as plugins from '../plugins.js';
 import { Handler } from './classes.handler.js';

-import * as interfaces from '../interfaces/index.js';
+import * as interfaces from '../../dist_ts_interfaces/index.js';

 export class HandlerTypedRouter extends Handler {
  /**
@ -11,7 +11,9 @@ export class HandlerTypedRouter extends Handler {
  constructor(typedrouter: plugins.typedrequest.TypedRouter) {
    super('POST', async (req, res) => {
      const response = await typedrouter.routeAndAddResponse(req.body);
-      res.json(plugins.smartjson.stringify(response));
+      res.type('json');
+      res.write(plugins.smartjson.stringify(response));
+      res.end();
    });
  }
 }
--- a/ts/servertools/classes.route.ts
+++ b/ts/servertools/classes.route.ts
@ -6,7 +6,13 @@ import { type IRoute as IExpressRoute } from 'express';

 export class Route {
  public routeString: string;
+
+  /**
+   * an object map of handlers
+   * Why multiple? Because GET, POST, PUT, DELETE, etc. can all have different handlers
+   */
  public handlerObjectMap = new plugins.lik.ObjectMap<Handler>();
+  
  public expressMiddlewareObjectMap = new plugins.lik.ObjectMap<any>();
  public expressRoute: IExpressRoute; // will be set to server route on server start
  constructor(ServerArg: Server, routeStringArg: string) {
--- a/ts/servertools/classes.server.ts
+++ b/ts/servertools/classes.server.ts
@ -9,7 +9,7 @@ import { setupRobots } from './tools.robots.js';
 import { setupManifest } from './tools.manifest.js';
 import { Sitemap } from './classes.sitemap.js';
 import { Feed } from './classes.feed.js';
-import { type IServerOptions } from '../typedserver.classes.typedserver.js';
+import { type IServerOptions } from '../classes.typedserver.js';
 export type TServerStatus = 'initiated' | 'running' | 'stopped';

 /**
@ -77,6 +77,11 @@ export class Server {
    return route;
  }

+  /**
+   * starts the server and sets up the routes
+   * @param portArg
+   * @param doListen
+   */
  public async start(portArg: number | string = this.options.port, doListen = true) {
    const done = plugins.smartpromise.defer();

@ -142,7 +147,24 @@ export class Server {
    });

    // body parsing
-    this.expressAppInstance.use(plugins.bodyParser.json({ limit: 100000000 })); // for parsing application/json
+    this.expressAppInstance.use(async (req, res, next) => {
+      if (req.headers['content-type'] === 'application/json') {
+        let data = '';
+        req.on('data', chunk => {
+          data += chunk;
+        });
+        req.on('end', () => {
+          try {
+            req.body = plugins.smartjson.parse(data);
+            next();
+          } catch (error) {
+            res.status(400).send('Invalid JSON');
+          }
+        });
+      } else {
+        next();
+      }
+    });
    this.expressAppInstance.use(plugins.bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded

    // robots
--- a/ts/servertools/index.ts
+++ b/ts/servertools/index.ts
@ -4,3 +4,9 @@ export * from './classes.handler.js';
 export * from './classes.handlerstatic.js';
 export * from './classes.handlerproxy.js';
 export * from './classes.handlertypedrouter.js';
+export * from './classes.compressor.js';
+import * as serviceworker from './tools.serviceworker.js';
+
+export {
+  serviceworker,
+}
--- a/ts/servertools/tools.serviceworker.ts
+++ b/ts/servertools/tools.serviceworker.ts
@ -0,0 +1,60 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+
+import * as interfaces from '../../dist_ts_interfaces/index.js'
+import { Handler } from './classes.handler.js';
+import type { TypedServer } from '../classes.typedserver.js';
+import { HandlerTypedRouter } from './classes.handlertypedrouter.js';
+
+const swBundleJs: string = plugins.smartfile.fs.toStringSync(
+  plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js')
+);
+const swBundleJsMap: string = plugins.smartfile.fs.toStringSync(
+  plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js.map')
+);
+let swVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
+  null;
+const serviceworkerHandler = new Handler(
+  'GET',
+  async (req, res) => {
+    if (req.path === '/serviceworker.bundle.js') {
+      res.status(200);
+      res.set('Content-Type', 'text/javascript');
+      res.write(swBundleJs + '\n' + `/** appSemVer: ${swVersionInfo?.appSemVer || 'not set'} */`);
+    } else if (req.path === '/serviceworker.bundle.js.map') {
+      res.status(200);
+      res.set('Content-Type', 'application/json');
+      res.write(swBundleJsMap);
+    }
+    res.end();
+  }
+);
+
+export const addServiceWorkerRoute = (
+  typedserverInstance: TypedServer,
+  swDataFunc: () => interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response']
+) => {
+  // lets the version info as unique string;
+  swVersionInfo = swDataFunc();
+
+  // the basic stuff
+  typedserverInstance.server.addRoute('/serviceworker.*', serviceworkerHandler);
+
+  // the typed stuff
+  const typedrouter = new plugins.typedrequest.TypedRouter();
+
+  typedrouter.addTypedHandler(
+    new plugins.typedrequest.TypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>(
+      'serviceworker_versionInfo',
+      async (req) => {
+        const versionInfoResponse = swDataFunc();
+        return versionInfoResponse;
+      }
+    )
+  );
+
+  typedserverInstance.server.addRoute(
+    '/sw-typedrequest',
+    new HandlerTypedRouter(typedrouter)
+  );
+};
--- a/ts/typedserver.paths.ts
+++ b/ts/typedserver.paths.ts
@ -1,8 +0,0 @@
-import * as plugins from './plugins.js';
-
-export const packageDir = plugins.path.join(
-  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
-  '../'
-);
-
-export const bundlePath = plugins.path.join(packageDir, './dist_ts_web/bundle.js');
--- a/ts/utilityservers/classes.serviceserver.ts
+++ b/ts/utilityservers/classes.serviceserver.ts
@ -0,0 +1,51 @@
+import { TypedServer } from '../classes.typedserver.js';
+import * as servertools from '../servertools/index.js';
+import * as plugins from '../plugins.js';
+
+export interface ILoleServiceServerConstructorOptions {
+  addCustomRoutes?: (serverArg: servertools.Server) => Promise<any>;
+  serviceName: string;
+  serviceVersion: string;
+  serviceDomain: string;
+  port?: number;
+}
+
+// the main service server
+export class UtilityServiceServer {
+  public options: ILoleServiceServerConstructorOptions;
+  public typedServer: TypedServer;
+
+  constructor(optionsArg: ILoleServiceServerConstructorOptions) {
+    this.options = optionsArg;
+  }
+
+  public async start() {
+    console.log('starting lole-serviceserver...')
+    this.typedServer = new TypedServer({
+      cors: true,
+      domain: this.options.serviceDomain,
+      forceSsl: false,
+      port: this.options.port || 3000,
+      robots: true,
+      defaultAnswer: async () => {
+        const InfoHtml = (await import('../infohtml/index.js')).InfoHtml;
+        return (
+          await InfoHtml.fromSimpleText(
+            `${this.options.serviceName} (version ${this.options.serviceVersion})`
+          )
+        ).htmlString;
+      },
+    });
+
+    // lets add any custom routes
+    if (this.options.addCustomRoutes) {
+      await this.options.addCustomRoutes(this.typedServer.server);
+    }
+
+    await this.typedServer.start();
+  }
+
+  public async stop() {
+    await this.typedServer.stop();
+  }
+}
--- a/ts/utilityservers/classes.websiteserver.ts
+++ b/ts/utilityservers/classes.websiteserver.ts
@ -0,0 +1,137 @@
+import * as interfaces from '../../dist_ts_interfaces/index.js';
+import { type IServerOptions, TypedServer } from '../classes.typedserver.js';
+import type { Request, Response } from '../index.js';
+import * as plugins from '../plugins.js';
+import * as servertools from '../servertools/index.js';
+
+export interface IUtilityWebsiteServerConstructorOptions {
+  addCustomRoutes?: (serverArg: servertools.Server) => Promise<any>;
+  appSemVer?: string;
+  domain: string;
+  serveDir: string;
+  feedMetadata: IServerOptions['feedMetadata'];
+}
+
+/**
+ * the utility website server implements a best practice server for websites
+ * It supports:
+ *  * live reload
+ *  * compression
+ *  * serviceworker
+ *  * pwa manifest
+ */
+export class UtilityWebsiteServer {
+  public options: IUtilityWebsiteServerConstructorOptions;
+  public typedserver: TypedServer;
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  constructor(optionsArg: IUtilityWebsiteServerConstructorOptions) {
+    this.options = optionsArg;
+  }
+
+  /**
+   *
+   */
+  public async start(portArg = 3000) {
+    this.typedserver = new TypedServer({
+      cors: true,
+      injectReload: true,
+      watch: true,
+      serveDir: this.options.serveDir,
+      enableCompression: true,
+      preferredCompressionMethod: 'gzip',
+      domain: this.options.domain,
+      forceSsl: false,
+      manifest: {
+        name: this.options.domain,
+        short_name: this.options.domain,
+        start_url: '/',
+        display_override: ['window-controls-overlay'],
+        lang: 'en',
+        background_color: '#000000',
+        scope: '/',
+      },
+      port: portArg,
+
+      // features
+      robots: true,
+      sitemap: true,
+    });
+
+    let lswData: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
+      {
+        appHash: 'xxxxxx',
+        appSemVer: this.options.appSemVer || 'x.x.x',
+      };
+
+    // -> /lsw* - anything regarding serviceworker
+    servertools.serviceworker.addServiceWorkerRoute(this.typedserver, () => {
+      return lswData;
+    });
+
+    // lets add ads.txt
+    this.typedserver.server.addRoute(
+      '/ads.txt',
+      new servertools.Handler('GET', async (req, res) => {
+        res.type('txt/plain');
+        const adsTxt =
+          ['google.com, pub-4104137977476459, DIRECT, f08c47fec0942fa0'].join('\n') + '\n';
+        res.write(adsTxt);
+        res.end();
+      })
+    );
+
+    this.typedserver.server.addRoute(
+      '/assetbroker/manifest/:manifestAsset',
+      new servertools.Handler('GET', async (req, res) => {
+        let manifestAssetName = req.params.manifestAsset;
+        if (manifestAssetName === 'favicon.png') {
+          manifestAssetName = `favicon_${this.options.domain
+            .replace('.', '')
+            .replace('losslesscom', 'lossless')}@2x_transparent.png`;
+        }
+        const fullOriginAssetUrl = `https://assetbroker.lossless.one/brandfiles/00general/${manifestAssetName}`;
+        console.log(`Getting ${manifestAssetName} from ${fullOriginAssetUrl}`);
+        const dataBuffer: Buffer = (await plugins.smartrequest.getBinary(fullOriginAssetUrl)).body;
+        res.type('.png');
+        res.write(dataBuffer);
+        res.end();
+      })
+    );
+
+    // lets add any custom routes
+    if (this.options.addCustomRoutes) {
+      await this.options.addCustomRoutes(this.typedserver.server);
+    }
+
+    // -> /*  - serve the files
+    this.typedserver.serveDirHashSubject.subscribe((appHash: string) => {
+      lswData = {
+        appHash,
+        appSemVer: '1.0.0',
+      };
+    });
+
+    // lets setup the typedrouter chain
+    this.typedserver.typedrouter.addTypedRouter(this.typedrouter);
+
+    // lets start everything
+    console.log('routes are all set. Startin up now!');
+    await this.typedserver.start();
+    console.log('typedserver started!');
+  }
+
+  public async stop() {
+    await this.typedserver.stop();
+  }
+
+  /**
+   * allows you to hanlde requests from other server instances without the need to listen for yourself
+   * note smartexpress allows you start the instance wuith passing >>false<< as second parameter to .start();
+   * @param req
+   * @param res
+   */
+  public async handleRequest(req: Request, res: Response) {
+    await this.typedserver.server.handleReqRes(req, res);
+  }
+}
--- a/ts/utilityservers/index.ts
+++ b/ts/utilityservers/index.ts
@ -0,0 +1,2 @@
+export * from './classes.serviceserver.js';
+export * from './classes.websiteserver.js';
--- a/ts_edgeworker/00_commitinfo_data.ts
+++ b/ts_edgeworker/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: 'cloudflare-workers',
+  version: '1.0.192',
+  description: 'cloudflare-workers'
+}
--- a/ts_edgeworker/analytics/analyzer.ts
+++ b/ts_edgeworker/analytics/analyzer.ts
@ -0,0 +1,83 @@
+
+import type { EdgeWorker } from '../classes.edgeworker.js';
+import type { WorkerEvent } from '../classes.workerevent.js';
+import * as plugins from '../plugins.js';
+import { SmartlogDestination } from './smartlog.js';
+
+export interface IAnalyticsData {
+  requestAgent: string;
+  requestUrl: string;
+  requestMethod: string;
+  requestStartTime: number;
+  responseStatus: number;
+  responseEndTime: number;
+}
+
+export class Analyzer {
+  cworkerEventRef: WorkerEvent;
+
+  public data: IAnalyticsData = {
+    requestAgent: 'unknown',
+    requestMethod: 'unknown',
+    requestUrl: 'unknown',
+    requestStartTime: 0,
+    responseStatus: 0,
+    responseEndTime: 0,
+  };
+
+  public finishedDeferred = plugins.smartpromise.defer();
+
+  constructor(cworkerEventRefArg: WorkerEvent) {
+    this.cworkerEventRef = cworkerEventRefArg;
+    this.smartlog.addLogDestination(new SmartlogDestination(this.cworkerEventRef.options.edgeWorkerRef));
+  }
+  public smartlog = new plugins.smartlog.Smartlog({
+    logContext: {
+      environment: 'production',
+      runtime: "cloudflare_workers",
+      zone: 'servezone',
+      company: 'Lossless GmbH',
+      companyunit: 'Lossless Cloud',
+      containerName: 'cloudflare_workers'
+    }
+  });
+
+  public setRequestData (optionsArg: {
+    requestAgent: string;
+    requestUrl: string;
+    requestMethod: string;
+  }) {
+    this.data = {
+      ...this.data,
+      ...{
+        requestAgent: optionsArg.requestAgent,
+        requestUrl: optionsArg.requestUrl,
+        requestMethod: optionsArg.requestMethod,
+        requestStartTime: Date.now()
+      }
+    };
+    
+  }
+
+  public setResponseData(optionsArg: {
+    responseStatus: number,
+    responseEndTime: number,
+  }) {
+    this.data = {
+      ...this.data,
+      ...{
+        responseStatus: optionsArg.responseStatus,
+        responseEndTime: optionsArg.responseEndTime
+      }
+    };
+    this.sendLogs();
+  }
+
+  public async sendLogs() {
+    await this.smartlog.log('info', `
+      Got a ${this.data.requestMethod} request from ${this.data.requestAgent} to
+      ${this.data.requestUrl}
+      that took ${this.data.responseEndTime - this.data.requestStartTime}ms to resolve with status ${this.data.responseStatus}.`, this.data);
+    this.finishedDeferred.resolve();
+  }
+}
--- a/ts_edgeworker/analytics/smartlog.ts
+++ b/ts_edgeworker/analytics/smartlog.ts
@ -0,0 +1,26 @@
+import * as smartlogInterfaces from '@push.rocks/smartlog-interfaces';
+import type { EdgeWorker } from '../classes.edgeworker.js';
+
+export class SmartlogDestination implements smartlogInterfaces.ILogDestination {
+  public edgeWorkerRef: EdgeWorker;
+
+  constructor(edgeworkerRefArg: EdgeWorker) {
+    this.edgeWorkerRef = edgeworkerRefArg;
+  }
+
+  public async handleLog(logPackageArg: smartlogInterfaces.ILogPackage) {
+    if (this.edgeWorkerRef.options.smartlogConfig) {
+      const requestBody: smartlogInterfaces.ILogPackageAuthenticated = {
+        auth: this.edgeWorkerRef.options.smartlogConfig.token,
+        logPackage: logPackageArg,
+      };
+      await fetch(this.edgeWorkerRef.options.smartlogConfig.endpoint, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify(requestBody),
+      });
+    }
+  }
+}
--- a/ts_edgeworker/classes.domainrouter.ts
+++ b/ts_edgeworker/classes.domainrouter.ts
@ -0,0 +1,67 @@
+import * as interfaces from './interfaces/index.js';
+import * as plugins from './plugins.js';
+import { WorkerEvent } from './classes.workerevent.js';
+
+import * as domainInstructions from './domaininstructions/index.js';
+
+export class DomainRouter {
+  private smartmatches: plugins.smartmatch.SmartMatch[] = [];
+
+  constructor() {
+    for (const key of Object.keys(domainInstructions.instructionObject)) {
+      this.smartmatches.push(new plugins.smartmatch.SmartMatch(key));
+    }
+  }
+
+  /**
+   *
+   * @param cworkerevent
+   */
+  public routeToResponder(cworkerevent: WorkerEvent) {
+    const match = this.smartmatches.find(smartmatchArg => {
+      return smartmatchArg.match(cworkerevent.request.url);
+    });
+    cworkerevent.responderInstruction = match
+      ? domainInstructions.instructionObject[match.wildcard]
+      : {
+          type: 'cache'
+        };
+  }
+
+  /**
+   * rendertronRouter
+   */
+  public checkWetherReRouteToRendertron(cworkerevent: WorkerEvent) {
+    let needsRendertron = false;
+    for (const botAgentIdentifier of domainInstructions.botUserAgents) {
+      if (needsRendertron) {
+        continue;
+      }
+      if (
+        cworkerevent.request.headers.get('user-agent') &&
+        cworkerevent.request.headers.get('user-agent').toLowerCase().includes(botAgentIdentifier.toLowerCase()) &&
+        !cworkerevent.request.url.includes('lossless.one')
+      ) {
+        needsRendertron = true;
+      }
+    }
+    if (needsRendertron) {
+      cworkerevent.routedThroughRendertron = true;
+    }
+  }
+
+  /**
+   * check wether this is a preflight request that should be handled
+   */
+  public checkWetherIsPreflight (cworkerevent: WorkerEvent) {
+    if (
+      cworkerevent.request.method === 'OPTIONS' &&
+      cworkerevent.request.headers.get('Origin') !== null &&
+      cworkerevent.request.headers.get('Access-Control-Request-Method') !== null &&
+      cworkerevent.request.headers.get('Access-Control-Request-Headers') !== null
+    ) {
+      cworkerevent.isPreflight = true;
+    }
+  }
+
+}
--- a/ts_edgeworker/classes.edgeworker.ts
+++ b/ts_edgeworker/classes.edgeworker.ts
@ -0,0 +1,73 @@
+// imports
+import { WorkerEvent } from './classes.workerevent.js';
+import { DomainRouter } from './classes.domainrouter.js';
+import * as plugins from './plugins.js';
+import * as responders from './responders/index.js';
+
+export interface IEdgeWorkerOptions {
+  smartlogConfig?: {
+    endpoint: string;
+    token: string;
+  }
+}
+
+export class EdgeWorker {
+  public options: IEdgeWorkerOptions;
+  domainRouter: DomainRouter;
+
+  constructor(optionsArg: IEdgeWorkerOptions = {}) {
+    this.options = optionsArg;
+    this.domainRouter = new DomainRouter();
+    addEventListener('fetch', this.fetchFunction as any);
+  }
+
+  public async fetchFunction (eventArg: plugins.cloudflareTypes.FetchEvent) {
+    if (new URL(eventArg.request.url).pathname.startsWith('/socket.io')) {
+      return;
+    }
+  
+    const cworkerEvent = new WorkerEvent({
+      edgeWorkerRef: this,
+      event: eventArg,
+      passThroughOnException: true
+    });
+  
+    // lets answer basic reuest things
+    responders.timeoutResponder(cworkerEvent);
+    cworkerEvent.hasResponse ? null : await responders.urlFormattingResponder(cworkerEvent);
+  
+    // lets route the domain
+    this.domainRouter.routeToResponder(cworkerEvent);
+    this.domainRouter.checkWetherReRouteToRendertron(cworkerEvent);
+    this.domainRouter.checkWetherIsPreflight(cworkerEvent);
+  
+    // guardresponder
+    cworkerEvent.hasResponse ? null : await responders.guardResponder(cworkerEvent);
+  
+    // lets process all requests that need rendertron
+    cworkerEvent.hasResponse ? null : await responders.rendertronResponder(cworkerEvent);
+  
+    // lets process all requests that are preflight requests
+    cworkerEvent.hasResponse ? null : await responders.preflightResponder(cworkerEvent);
+  
+    switch (cworkerEvent.responderInstruction.type) {
+      case 'cache':
+        cworkerEvent.hasResponse ? null : await responders.cacheResponder(cworkerEvent);
+        break;
+      case 'origin':
+        cworkerEvent.hasResponse ? null : await responders.originResponder(cworkerEvent);
+        break;
+      case 'redirect':
+        cworkerEvent.hasResponse ? null : await responders.adsTxtResponder(cworkerEvent);
+        break;
+      case 'static':
+        cworkerEvent.hasResponse ? null : await responders.staticResponder(cworkerEvent);
+        break;
+      case 'ads.txt':
+        cworkerEvent.hasResponse ? null : await responders.adsTxtResponder(cworkerEvent);
+        break;
+    }
+    // cworkerEvent.hasResponse ? null : await responders.kvResponder(cworkerEvent);
+    cworkerEvent.hasResponse ? null : await responders.errorResponder(cworkerEvent);
+  };
+}
--- a/ts_edgeworker/classes.kvhandler.ts
+++ b/ts_edgeworker/classes.kvhandler.ts
@ -0,0 +1,37 @@
+import * as interfaces from './interfaces/index.js';
+import * as plugins from './plugins.js';
+
+declare var lokv: plugins.cloudflareTypes.KVNamespace;
+
+/**
+ * an abstraction for the workerd KV store
+ */
+export class KVHandler {
+  private getSafeIdentifier(urlString: string) {
+    return encodeURI(urlString);
+  }
+
+  async getFromKv(keyIdentifier: string) {
+    const key = this.getSafeIdentifier(keyIdentifier);
+    const valueString = await lokv.get(key);
+    return valueString;
+  }
+
+  async putInKv(keyIdentifier: string, valueForStorage: string) {
+    const key = this.getSafeIdentifier(keyIdentifier);
+    const value = valueForStorage;
+    await lokv.put(key, value);
+    return null;
+  }
+
+  /**
+   * deletes a key/value from the cache
+   * @param keyIdentifier
+   */
+  async deleteInKv(keyIdentifier: string) {
+    const cacheKey = this.getSafeIdentifier(keyIdentifier);
+    await lokv.delete(cacheKey);
+  }
+}
+
+export const kvHandlerInstance = new KVHandler();
--- a/ts_edgeworker/classes.responsekv.ts
+++ b/ts_edgeworker/classes.responsekv.ts
@ -0,0 +1,46 @@
+import * as plugins from './plugins.js';
+import { kvHandlerInstance } from './classes.kvhandler.js';
+
+declare var lokv: plugins.cloudflareTypes.KVNamespace;
+
+interface IKVResponseObject {
+  headers: { [key: string]: string };
+  version: string;
+  body: string;
+}
+
+export class ResponseKv {
+  public async storeResponse(urlIdentifier: string, responseArg: any) {
+    const headers: { [key: string]: string } = {};
+    for (const kv of responseArg.headers.entries()) {
+      headers[kv[0]] = kv[1];
+    }
+    const kvResponseForStorage: IKVResponseObject = {
+      headers,
+      version: '1.0.0',
+      body: await responseArg.text()
+    };
+    await kvHandlerInstance.putInKv(urlIdentifier, JSON.stringify(kvResponseForStorage));
+  }
+
+  public async getResponse(urlIdentifier: string): Promise<Response> {
+    const kvValue = await kvHandlerInstance.getFromKv(urlIdentifier);
+    if (kvValue) {
+      let kvResponse: IKVResponseObject;
+      try {
+        kvResponse = JSON.parse(kvValue);
+      } catch (e) {
+        console.log(e);
+        return null;
+      }
+      const headers = new Headers();
+      for (const key of Object.keys(kvResponse.headers)) {
+        headers.append(key, kvResponse.headers[key]);
+      }
+      headers.append('SERVEZONE_ROUTE', 'CLOUDFLARE_EDGE_LOKV');
+      return new Response(kvResponse.body, { headers: headers });
+    } else {
+      return null;
+    }
+  }
+}
--- a/ts_edgeworker/classes.workerevent.ts
+++ b/ts_edgeworker/classes.workerevent.ts
@ -0,0 +1,102 @@
+import * as interfaces from './interfaces/index.js';
+import * as plugins from './plugins.js';
+import * as helpers from './helpers/index.js';
+import { DomainRouter } from './classes.domainrouter.js';
+import { Analyzer } from './analytics/analyzer.js';
+import type { EdgeWorker } from './classes.edgeworker.js';
+
+export interface ICworkerEventOptions {
+  event: plugins.cloudflareTypes.FetchEvent
+  edgeWorkerRef: EdgeWorker;
+  passThroughOnException?: boolean;
+}
+
+
+export class WorkerEvent {
+  public options: ICworkerEventOptions;
+
+  public analyzer: Analyzer;
+  private responseDeferred: plugins.smartpromise.Deferred<any>;
+  private waitUntilDeferred: plugins.smartpromise.Deferred<any>;
+  
+  private response: Response = null;
+  private waitList = [];
+
+  // routing settings
+  public responderInstruction: interfaces.IResponderInstruction;
+  public routedThroughRendertron: boolean = false;
+  public isPreflight: boolean = false;
+
+  public request: plugins.cloudflareTypes.Request;
+
+  public parsedUrl: URL;
+
+  constructor(optionsArg: ICworkerEventOptions) {
+    this.options = optionsArg;
+
+    // lets create an Analyzer for this request
+    this.analyzer = new Analyzer(this);
+
+    // lets make sure we always answer
+    this.options.passThroughOnException ? this.options.event.passThroughOnException() : null;
+
+    // lets set up some better asnyc behaviour
+    this.waitUntilDeferred = plugins.smartpromise.defer();
+    this.responseDeferred = plugins.smartpromise.defer();
+    this.addToWaitList(this.analyzer.finishedDeferred.promise);
+
+    // lets entangle the event with this class instance
+    this.request = this.options.event.request;
+
+    // lets start with analytics
+    this.analyzer.setRequestData({
+      requestAgent: this.request.headers.get('user-agent'),
+      requestMethod: this.request.method,
+      requestUrl: this.request.url
+    });
+
+
+    this.options.event.respondWith(this.responseDeferred.promise);
+    this.options.event.waitUntil(this.waitUntilDeferred.promise);
+
+    // lets parse the url
+    this.parsedUrl = new URL(this.request.url);
+
+    // lets check the waitlist
+    this.checkWaitList();
+    console.log(`Got request for ${this.request.url}`);
+  }
+
+  get hasResponse () {
+    let returnValue: boolean;
+    this.response ? returnValue = true : returnValue = false;
+    return returnValue;
+  }
+
+  public addToWaitList(promiseArg: Promise<any>) {
+    this.waitList.push(promiseArg);
+  }
+
+  private async checkWaitList() {
+    await this.responseDeferred.promise;
+    const currentWaitList = this.waitList;
+    this.waitList = [];
+    await Promise.all(currentWaitList);
+    if (this.waitList.length > 0) {
+      this.checkWaitList();
+    } else {
+      this.waitUntilDeferred.resolve();
+    }
+  }
+
+  public setResponse (responseArg: Response) {
+    this.response = responseArg;
+    this.responseDeferred.resolve(responseArg);
+    this.analyzer.setResponseData({
+      responseStatus: this.response.status,
+      responseEndTime: Date.now()
+    });
+  }
+
+  
+}
--- a/ts_edgeworker/domaininstructions/botuseragents.ts
+++ b/ts_edgeworker/domaininstructions/botuseragents.ts
@ -0,0 +1,36 @@
+export const botUserAgents = [
+  // Baidu
+  'baiduspider',
+  'embedly',
+
+  // Facebook
+  'facebookexternalhit',
+
+  // Ghost
+  'Ghost',
+  
+  // Microsoft
+  'bingbot',
+  'BingPreview',
+  'linkedinbot',
+  'MissinglettrBot',
+  'msnbot',
+  'outbrain',
+  'pinterest',
+  'quora link preview',
+  'rogerbot',
+  'showyoubot',
+  'slackbot',
+  'TelegramBot',
+
+  // Twitter
+  'twitterbot',
+  'vkShare',
+  'W3C_Validator',
+
+  // WhatsApp
+  'whatsapp',
+
+  // woorank
+  'woorank'
+];
--- a/ts_edgeworker/domaininstructions/domaininstructions.ts
+++ b/ts_edgeworker/domaininstructions/domaininstructions.ts
@ -0,0 +1,7 @@
+import * as interfaces from '../interfaces/index.js';
+
+export const instructionObject: { [key: string]: interfaces.IResponderInstruction } = {
+  '*/ads.txt': {
+    type: 'ads.txt',
+  }
+};
--- a/ts_edgeworker/domaininstructions/index.ts
+++ b/ts_edgeworker/domaininstructions/index.ts
@ -0,0 +1,2 @@
+export * from './botuseragents.js';
+export * from './domaininstructions.js';
--- a/ts_edgeworker/helpers/checks.ts
+++ b/ts_edgeworker/helpers/checks.ts
@ -0,0 +1,9 @@
+import * as plugins from '../plugins.js';
+declare var lokv: plugins.cloudflareTypes.KVNamespace;
+export const checkLokv = () => {
+  if (!lokv) {
+    throw new Error('lokv not defined!');
+  } else {
+    console.log('lokv present!');
+  }
+};
--- a/ts_edgeworker/helpers/index.ts
+++ b/ts_edgeworker/helpers/index.ts
@ -0,0 +1 @@
+export * from './checks.js';
--- a/ts_edgeworker/index.ts
+++ b/ts_edgeworker/index.ts
@ -0,0 +1 @@
+export * from './classes.edgeworker.js';
--- a/ts_edgeworker/interfaces/custom.ts
+++ b/ts_edgeworker/interfaces/custom.ts
@ -0,0 +1,9 @@
+import { WorkerEvent } from "../classes.workerevent.js";
+
+export interface IResponderInstruction {
+  type: 'origin' | 'cache' | 'static' | 'redirect' | 'ads.txt';
+  cacheClientSideForMin?: number;
+  redirectUrl?: string;
+}
+
+export type TRequestResponser = (workerEventArg: WorkerEvent) => Promise<void>;
--- a/ts_edgeworker/interfaces/index.ts
+++ b/ts_edgeworker/interfaces/index.ts
@ -0,0 +1 @@
+export * from './custom.js';
--- a/ts_edgeworker/plugins.ts
+++ b/ts_edgeworker/plugins.ts
@ -0,0 +1,21 @@
+// @pushrocks scope
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartlogInterfaces from '@push.rocks/smartlog-interfaces';
+import * as smartmatch from '@push.rocks/smartmatch';
+import * as smartpromise from '@push.rocks/smartpromise';
+
+export {
+  smartdelay,
+  smartlog,
+  smartlogInterfaces,
+  smartmatch,
+  smartpromise
+};
+
+// cloudflarea
+import * as cloudflareTypes from '@cloudflare/workers-types';
+
+export {
+  cloudflareTypes
+}
--- a/ts_edgeworker/responders/adstxt.responder.ts
+++ b/ts_edgeworker/responders/adstxt.responder.ts
@ -0,0 +1,14 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const adsTxtResponder: interfaces.TRequestResponser = async (cWorkerEventArg: WorkerEvent) => {
+  if (cWorkerEventArg.responderInstruction.type === 'ads.txt') {
+    const response = new Response('google.com, pub-4104137977476459, DIRECT, f08c47fec0942fa0\n', {
+      headers: {
+        'Content-Type': 'text/plain; charset=utf-8'
+      }
+    })
+    cWorkerEventArg.setResponse(response);
+  }
+
+};
--- a/ts_edgeworker/responders/cache.responder.ts
+++ b/ts_edgeworker/responders/cache.responder.ts
@ -0,0 +1,92 @@
+import * as interfaces from '../interfaces/index.js';
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+import { kvHandlerInstance } from '../classes.kvhandler.js';
+
+declare const fetch: plugins.cloudflareTypes.Fetcher['fetch']; 
+
+declare var caches: any;
+export const cacheResponder: interfaces.TRequestResponser = async (cworkerEventArg: WorkerEvent) => {
+  const host = cworkerEventArg.request.headers.get('Host');
+  const appHashKey = `${host.toLowerCase()}_appHash`;
+  const appHash = await kvHandlerInstance.getFromKv(appHashKey);
+
+  const cache = caches.default;
+  let response: Response = await cache.match(cworkerEventArg.request);
+
+  if (
+    response &&
+    response.headers.get('appHash') &&
+    response.headers.get('appHash') !== appHash
+  ) {
+    response = null;
+  }
+
+  if (response) {
+    cworkerEventArg.setResponse(response);
+  } else {
+    response = await handleNewRequest(cworkerEventArg.request);
+    if (response) {
+      cworkerEventArg.addToWaitList(new Promise<void>(async (resolve, reject) => {
+        const newAppHash = response.headers.get('appHash');
+        if (newAppHash) {
+          await kvHandlerInstance.putInKv(appHashKey, newAppHash);
+        }
+        resolve();
+      }));
+      cworkerEventArg.addToWaitList(buildCacheResponse(cache, cworkerEventArg.request, response));
+      cworkerEventArg.setResponse(response);
+    }
+  }
+};
+
+/**
+ * @param {Request} originalRequest
+ */
+const handleNewRequest = async (originalRequest: plugins.cloudflareTypes.Request): Promise<Response> => {
+  console.log('answering from origin');
+  const originResponse: any = await fetch(
+    originalRequest
+  );
+
+  // lets capture status
+  if (originResponse.status > 399) {
+    return null;
+  }
+
+  const responseClientPassThroughStream = new TransformStream();
+  originResponse.body.pipeTo(responseClientPassThroughStream.writable);
+
+  // build response for client
+  const clientHeaders = new Headers();
+  for (const kv of originResponse.headers.entries()) {
+    clientHeaders.append(kv[0], kv[1]);
+  }
+  clientHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_ORIGIN_INITIAL');
+  const responseForClient = new Response(responseClientPassThroughStream.readable, {
+    ...originResponse,
+    headers: clientHeaders
+  });
+
+  // lets return the responses
+  return responseForClient;
+};
+
+const buildCacheResponse = async (cache, matchRequest: plugins.cloudflareTypes.Request, originResponse: any) => {
+  const cacheHeaders = new Headers();
+  for (const kv of originResponse.headers.entries()) {
+    cacheHeaders.append(kv[0], kv[1]);
+  }
+  cacheHeaders.delete('SERVEZONE_ROUTE');
+  cacheHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_CACHE');
+  cacheHeaders.delete('Cache-Control');
+  cacheHeaders.append('Cache-Control', 'public, max-age=60');
+  cacheHeaders.delete('Expires');
+  cacheHeaders.append('Expires', new Date(Date.now() + 60 * 1000).toUTCString());
+
+  const responseForCache = new Response(await originResponse.clone().body, {
+    ...originResponse,
+    headers: cacheHeaders
+  });
+  await cache.put(matchRequest, responseForCache);
+};
--- a/ts_edgeworker/responders/error.responder.ts
+++ b/ts_edgeworker/responders/error.responder.ts
@ -0,0 +1,6 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+export const errorResponder: interfaces.TRequestResponser = async (cWorkerEvent: WorkerEvent) => {
+  const errorResponse = await fetch('https://nullresolve.lossless.one/status/firewall');
+  cWorkerEvent.setResponse(errorResponse);
+};
--- a/ts_edgeworker/responders/guard.responder.ts
+++ b/ts_edgeworker/responders/guard.responder.ts
@ -0,0 +1,8 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+export const guardResponder: interfaces.TRequestResponser = async (cWorkerEvent: WorkerEvent) => {
+  if (cWorkerEvent.parsedUrl.pathname.endsWith('.map')) {
+    const errorResponse = await fetch('https://nullresolve.lossless.one/status/firewall');
+    cWorkerEvent.setResponse(errorResponse);
+  }
+};
--- a/ts_edgeworker/responders/index.ts
+++ b/ts_edgeworker/responders/index.ts
@ -0,0 +1,12 @@
+export * from './adstxt.responder.js';
+export * from './cache.responder.js';
+export * from './urlformatting.responder.js';
+export * from './error.responder.js';
+export * from './guard.responder.js';
+export * from './kv.responder.js';
+export * from './origin.responder.js';
+export * from './preflight.responder.js';
+export * from './redirect.reponder.js';
+export * from './rendertron.responder.js';
+export * from './static.responder.js';
+export * from './timeout.responder.js';
--- a/ts_edgeworker/responders/kv.responder.ts
+++ b/ts_edgeworker/responders/kv.responder.ts
@ -0,0 +1,34 @@
+import * as interfaces from '../interfaces/index.js';
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+import { ResponseKv } from '../classes.responsekv.js';
+
+declare const fetch: plugins.cloudflareTypes.Fetcher['fetch']; 
+
+export const kvResponder: interfaces.TRequestResponser = async (cworkerEventArg: WorkerEvent) => {
+  const responseKvInstance = new ResponseKv();
+  let response = await responseKvInstance.getResponse(cworkerEventArg.request.url);
+  if (response) {
+    console.log('Got response from KV');
+  } else {
+    response = await handleNewRequest(cworkerEventArg.request, responseKvInstance);
+  }
+  cworkerEventArg.setResponse(response);
+};
+
+const handleNewRequest = async (request: plugins.cloudflareTypes.Request, responseKvInstance: ResponseKv) => {
+  const originResponse: any = await fetch(request);
+  // build response for cache
+  const cacheHeaders = new Headers();
+  for (const kv of originResponse.headers.entries()) {
+    cacheHeaders.append(kv[0], kv[1]);
+  }
+  cacheHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_KVRESPONSE');
+  cacheHeaders.append('Cache-Control', 'max-age=600');
+  const responseForKV = new Response(await originResponse.body, {
+    ...originResponse,
+    headers: cacheHeaders
+  });
+  await responseKvInstance.storeResponse(request.url, responseForKV.clone());
+  return responseForKV.clone();
+};
--- a/ts_edgeworker/responders/origin.responder.ts
+++ b/ts_edgeworker/responders/origin.responder.ts
@ -0,0 +1,31 @@
+import * as interfaces from '../interfaces/index.js';
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+declare const fetch: plugins.cloudflareTypes.Fetcher['fetch'];
+
+export const originResponder: interfaces.TRequestResponser = async (eventArg: WorkerEvent) => {
+  const originResponse: any = await fetch(eventArg.request);
+  // lets capture status
+  if (originResponse.status > 399) {
+    return;
+  }
+
+  const headers = new Headers();
+  for (const kv of originResponse.headers.entries()) {
+    headers.append(kv[0], kv[1]);
+  }
+  headers.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_FASTORIGIN');
+
+  const responsePassThroughStream = new TransformStream();
+  originResponse.body.pipeTo(responsePassThroughStream.writable);
+
+  // response
+
+  const responseForClient = new Response(responsePassThroughStream.readable, {
+    ...originResponse,
+    headers,
+  });
+
+  eventArg.setResponse(responseForClient);
+};
--- a/ts_edgeworker/responders/preflight.responder.ts
+++ b/ts_edgeworker/responders/preflight.responder.ts
@ -0,0 +1,18 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const preflightResponder: interfaces.TRequestResponser = async (eventArg: WorkerEvent) => {
+  if (eventArg.isPreflight) {
+    const corsHeaders = new Headers();
+    corsHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_PREFLIGHT');
+    corsHeaders.append('Access-Control-Allow-Origin', '*');
+    corsHeaders.append('Access-Control-Allow-Methods', '*');
+    corsHeaders.append('Access-Control-Allow-Headers', '*');
+
+    eventArg.setResponse(
+      new Response(null, {
+        headers: corsHeaders,
+      })
+    );
+  }
+};
--- a/ts_edgeworker/responders/redirect.reponder.ts
+++ b/ts_edgeworker/responders/redirect.reponder.ts
@ -0,0 +1,9 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const redirectResponder: interfaces.TRequestResponser = async (cWorkerEventArg: WorkerEvent) => {
+  if (cWorkerEventArg.responderInstruction.type === 'redirect') {
+    cWorkerEventArg.setResponse(Response.redirect(cWorkerEventArg.responderInstruction.redirectUrl, 302));
+  }
+
+};
--- a/ts_edgeworker/responders/rendertron.responder.ts
+++ b/ts_edgeworker/responders/rendertron.responder.ts
@ -0,0 +1,22 @@
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const rendertronResponder = async (cworkerevent: WorkerEvent) => {
+  if (cworkerevent.routedThroughRendertron) {
+    const oldHeaders: any = cworkerevent.request.headers;
+    const rendertronHeaders = new Headers();
+    for (const kv of oldHeaders.entries()) {
+      const headerName = kv[0];
+      const headerValue = headerName === 'user-agent' ? 'Lossless Rendertron' : kv[1];
+      rendertronHeaders.append(headerName, headerValue);
+    }
+    const rendertronRequest = new Request(
+      `https://rendertron.lossless.one/render/${cworkerevent.request.url}`,
+      {
+        method: cworkerevent.request.method,
+        headers: rendertronHeaders
+      }
+    );
+    cworkerevent.setResponse(await fetch(rendertronRequest));
+  }
+};
--- a/ts_edgeworker/responders/static.responder.ts
+++ b/ts_edgeworker/responders/static.responder.ts
@ -0,0 +1,31 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const staticResponder: interfaces.TRequestResponser = async (cWorkerEventArg: WorkerEvent) => {
+  if (cWorkerEventArg.responderInstruction.type === 'static') {
+    const originResponse: any = await fetch(
+      `https://statichost.lossless.one/resolve?url=${encodeURI(cWorkerEventArg.request.url)}`
+    );
+
+    const cacheHeaders = new Headers();
+    for (const kv of originResponse.headers.entries()) {
+      cacheHeaders.append(kv[0], kv[1]);
+    }
+    cacheHeaders.delete('SERVEZONE_ROUTE');
+    cacheHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_STATICHOST');
+    
+    if (cWorkerEventArg.responderInstruction.cacheClientSideForMin) {
+      cacheHeaders.delete('Cache-Control');
+      cacheHeaders.append('Cache-Control', `public, max-age=${cWorkerEventArg.responderInstruction.cacheClientSideForMin * 60}`);
+      cacheHeaders.delete('Expires');
+      cacheHeaders.append('Expires', new Date(Date.now() + cWorkerEventArg.responderInstruction.cacheClientSideForMin * 1000).toUTCString());
+    }
+
+    const responseForClient = new Response(await originResponse.clone().body, {
+      ...originResponse,
+      headers: cacheHeaders
+    });
+
+    cWorkerEventArg.setResponse(responseForClient);
+  }
+};
--- a/ts_edgeworker/responders/timeout.responder.ts
+++ b/ts_edgeworker/responders/timeout.responder.ts
@ -0,0 +1,23 @@
+import * as interfaces from '../interfaces/index.js';
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const timeoutResponder: interfaces.TRequestResponser = async (cWorkerEvent: WorkerEvent) => {
+  await plugins.smartdelay.delayFor(10000);
+  if (cWorkerEvent.routedThroughRendertron) {
+    await plugins.smartdelay.delayFor(10000);
+  }
+  if (!cWorkerEvent.hasResponse) {
+    const errorResponse = await fetch(
+      `https://nullresolve.lossless.one/custom?title=${encodeURI(
+        `Lossless Network: Request Cancellation!`
+      )}&heading=${encodeURI(`Error: Request Cancellation`)}&text=${encodeURI(
+        `Lossless Network could not decide how to respond to this request within 5 seconds. Therefore it timed out and has been canceled.
+        <p>requestUrl: ${cWorkerEvent.request.url}<br>
+        requestTime: ${Date.now()}<br>
+        referenceNumber: xxxxxx</p>`
+      )}`
+    );
+    cWorkerEvent.setResponse(errorResponse);
+  }
+};
--- a/ts_edgeworker/responders/urlformatting.responder.ts
+++ b/ts_edgeworker/responders/urlformatting.responder.ts
@ -0,0 +1,21 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const urlFormattingResponder: interfaces.TRequestResponser = async (eventArg: WorkerEvent) => {
+  let shouldCorrect = false;
+  const correctedUrl = new URL(eventArg.request.url);
+  if (eventArg.parsedUrl.hostname.startsWith('www.')) {
+    shouldCorrect = true;
+    correctedUrl.hostname = eventArg.parsedUrl.hostname.substring(
+      4,
+      eventArg.parsedUrl.hostname.length
+    );
+  }
+  if (eventArg.parsedUrl.protocol.startsWith('http:')) {
+    shouldCorrect = true;
+    correctedUrl.protocol = 'https:';
+  }
+  if (shouldCorrect) {
+    eventArg.setResponse(Response.redirect(`${correctedUrl.protocol}//${correctedUrl.host}${correctedUrl.pathname}${correctedUrl.search}`, 301));
+  }
+};
--- a/ts_edgeworker/versionhandler.ts
+++ b/ts_edgeworker/versionhandler.ts
@ -0,0 +1,7 @@
+import * as interfaces from './interfaces/index.js';
+
+export class VersionHandler {
+
+}
+
+export const versionHandlerInstance = new VersionHandler();
--- a/ts_interfaces/index.ts
+++ b/ts_interfaces/index.ts
@ -1,3 +1,9 @@
 export * from './requestmodifier.js';
 export * from './responsemodifier.js';
 export * from './typedrequests.js';
+
+import * as serviceworker from './serviceworker.js';
+
+export {
+  serviceworker,
+}
--- a/ts_interfaces/plugins.ts
+++ b/ts_interfaces/plugins.ts
@ -0,0 +1,5 @@
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
+
+export {
+  typedrequestInterfaces,
+}
--- a/ts_interfaces/requestmodifier.ts
+++ b/ts_interfaces/requestmodifier.ts
--- a/ts_interfaces/responsemodifier.ts
+++ b/ts_interfaces/responsemodifier.ts
--- a/ts_interfaces/serviceworker.ts
+++ b/ts_interfaces/serviceworker.ts
@ -0,0 +1,127 @@
+import * as plugins from './plugins.js';
+
+export interface CacheStorage {
+  keys: () => Promise<string[]>;
+  match: any;
+  open: any;
+  delete: any;
+}
+export declare var caches: CacheStorage;
+
+
+// =============================
+// Interfaces for communication
+// =============================
+
+export interface IMessage_Serviceworker_Client_UpdateInfo
+  extends plugins.typedrequestInterfaces.implementsTR<
+    plugins.typedrequestInterfaces.ITypedRequest,
+    IMessage_Serviceworker_Client_UpdateInfo
+  > {
+  method: 'serviceworker_newVersion';
+  request: {
+    appVersion: string;
+    appHash: string;
+  };
+  response: {};
+}
+
+export interface IMessage_Serviceworker_Client_RequestReload
+  extends plugins.typedrequestInterfaces.implementsTR<
+    plugins.typedrequestInterfaces.ITypedRequest,
+    IMessage_Serviceworker_Client_RequestReload
+  > {
+  method: 'serviceworker_requestReload';
+  request: {};
+  response: {};
+}
+
+export interface IRequest_Serviceworker_Backend_VersionInfo
+  extends plugins.typedrequestInterfaces.implementsTR<
+    plugins.typedrequestInterfaces.ITypedRequest,
+    IRequest_Serviceworker_Backend_VersionInfo
+  > {
+  method: 'serviceworker_versionInfo';
+  request: {};
+  response: {
+    appHash: string;
+    appSemVer: string;
+  };
+}
+
+// ===============
+// web
+// ===============
+/**
+ * purges the service workers cache
+ */
+export interface IRequest_PurgeServiceWorkerCache extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_PurgeServiceWorkerCache
+> {
+  method: 'purgeServiceWorkerCache';
+  request: {};
+  response: {};
+}
+
+/**
+ * updates the info in all connected tabs
+ */
+export interface IMessage_Serviceworker_Client_UpdateInfo
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IMessage_Serviceworker_Client_UpdateInfo
+  > {
+  method: 'serviceworker_newVersion';
+  request: {
+    appVersion: string;
+    appHash: string;
+  };
+  response: {};
+}
+
+/**
+ * requests all clients to reload
+ */
+export interface IMessage_Serviceworker_Client_RequestReload
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IMessage_Serviceworker_Client_RequestReload
+  > {
+  method: 'serviceworker_requestReload';
+  request: {};
+  response: {};
+}
+
+/**
+ * updates version infos
+ */
+export interface IRequest_Serviceworker_Backend_VersionInfo
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_Backend_VersionInfo
+  > {
+  method: 'serviceworker_versionInfo';
+  request: {};
+  response: {
+    appHash: string;
+    appSemVer: string;
+  };
+}
+
+/**
+ * ensures a stable connection between clients and the serviceworker
+ */
+export interface IRequest_Client_Serviceworker_ConnectionPolling
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Client_Serviceworker_ConnectionPolling
+  > {
+  method: 'broadcastConnectionPolling',
+  request: {
+    tabId: string;
+  },
+  response: {
+    serviceworkerId: string;
+  }
+}
--- a/ts_interfaces/typedrequests.ts
+++ b/ts_interfaces/typedrequests.ts
--- a/ts_web/00_commitinfo_data.ts
+++ b/ts_web/00_commitinfo_data.ts
@ -1,8 +0,0 @@
-/**
- * autocreated commitinfo by @pushrocks/commitinfo
- */
-export const commitinfo = {
-  name: '@api.global/typedserver',
-  version: '3.0.22',
-  description: 'easy serving of static files'
-}
--- a/ts_web_inject/00_commitinfo_data.ts
+++ b/ts_web_inject/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@api.global/typedserver',
+  version: '3.0.29',
+  description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
+}
--- a/ts_web_inject/index.ts
+++ b/ts_web_inject/index.ts
@ -1,5 +1,5 @@
 import * as plugins from './typedserver_web.plugins.js';
-import * as interfaces from '../ts/interfaces/index.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
 import { logger } from './typedserver_web.logger.js';
 logger.log('info', `TypedServer-Devtools initialized!`);

--- a/ts_web_inject/typedserver_web.infoscreen.ts
+++ b/ts_web_inject/typedserver_web.infoscreen.ts
--- a/ts_web_inject/typedserver_web.logger.ts
+++ b/ts_web_inject/typedserver_web.logger.ts
--- a/ts_web_inject/typedserver_web.plugins.ts
+++ b/ts_web_inject/typedserver_web.plugins.ts
--- a/ts_web_serviceworker/00_commitinfo_data.ts
+++ b/ts_web_serviceworker/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@losslessone_private/lole-serviceworker',
+  version: '1.0.206',
+  description: 'serviceworker implementation for lossless websites'
+}
--- a/ts_web_serviceworker/classes.backend.ts
+++ b/ts_web_serviceworker/classes.backend.ts
@ -0,0 +1,53 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+
+/**
+ * This class is meant to be used only on the backend side
+ */
+export class ServiceworkerBackend {
+  public deesComms = new plugins.deesComms.DeesComms();
+
+  constructor(optionsArg: {
+    self: any;
+    purgeCache: (reqArg: interfaces.serviceworker.IRequest_PurgeServiceWorkerCache['request']) => Promise<interfaces.serviceworker.IRequest_PurgeServiceWorkerCache['response']>;
+  }) {
+
+    // lets handle wakestuff
+    optionsArg.self.addEventListener('message', (event) => {
+      if (event.data && event.data.type === 'wakeUpCall') {
+        console.log('sw-backend: got wake up call');
+      }
+    });
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Client_Serviceworker_ConnectionPolling>('broadcastConnectionPolling', async reqArg => {
+      return {
+        serviceworkerId: '123'
+      };
+    })
+
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_PurgeServiceWorkerCache>('purgeServiceWorkerCache', async reqArg => {
+      console.log(`Executing purge cache in serviceworker backend.`)
+      return await optionsArg.purgeCache?.(reqArg);
+    });
+  }
+
+  /**
+   * reloads all clients
+   */
+  public async triggerReloadAll() {
+
+  }
+
+  /**
+   * display notification
+   */
+  public async addNotification(notificationArg: {
+    title: string;
+    body: string;
+  }) {
+    
+  }
+
+  public async alert(alertText: string) {
+    
+  }
+}
--- a/ts_web_serviceworker/classes.cachemanager.ts
+++ b/ts_web_serviceworker/classes.cachemanager.ts
@ -0,0 +1,292 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './env.js';
+import { logger } from './logging.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+
+export class CacheManager {
+  public losslessServiceWorkerRef: ServiceWorker;
+
+  public usedCacheNames = {
+    runtimeCacheName: 'runtime'
+  };
+
+  /**
+   * Hard cached domains are always attempted to be cached.
+   * For example, your internal origin, fonts, CDNs, etc.
+   */
+  public hardCachedDomains: string[];
+
+  /**
+   * Soft cached domains will be cached normally on non‑Safari browsers,
+   * but on Safari caching is bypassed to avoid CORS issues.
+   */
+  public softCachedDomains: string[];
+
+  constructor(losslessServiceWorkerRefArg: ServiceWorker) {
+    this.losslessServiceWorkerRef = losslessServiceWorkerRefArg;
+
+    // Default hard cached domains.
+    this.hardCachedDomains = [
+      this.losslessServiceWorkerRef.serviceWindowRef.location.origin,
+      'https://unpkg.com',
+      'https://fonts.googleapis.com',
+      'https://fonts.gstatic.com'
+    ];
+
+    // Default soft cached domains.
+    this.softCachedDomains = [
+      'https://assetbroker.'
+    ];
+
+    this._setupCache();
+  }
+
+  /**
+   * Returns true if the given URL matches a hard cached domain.
+   */
+  private isHardCached(url: string): boolean {
+    return this.hardCachedDomains.some(domain => url.includes(domain));
+  }
+
+  /**
+   * Returns true if the given URL matches a soft cached domain.
+   */
+  private isSoftCached(url: string): boolean {
+    return this.softCachedDomains.some(domain => url.includes(domain));
+  }
+
+  /**
+   * Returns true if the given URL should be cached (hard or soft).
+   */
+  private isCacheable(url: string): boolean {
+    return this.isHardCached(url) || this.isSoftCached(url);
+  }
+
+  /**
+   * Creates a new Request with appropriate CORS settings.
+   */
+  private createMatchRequest(requestArg: Request): Request {
+    let matchRequest: Request;
+    // For internal requests, use the original request.
+    if (requestArg.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin)) {
+      matchRequest = requestArg;
+    } else {
+      // For external requests, choose the request mode based on whether the URL is soft-cached.
+      const isSoft = this.isSoftCached(requestArg.url);
+      // For soft cached domains we use 'no-cors' to avoid CORS errors (at the expense of an opaque response).
+      const mode: RequestMode = isSoft ? 'no-cors' : 'cors';
+      matchRequest = new Request(requestArg.url, {
+        method: requestArg.method,
+        headers: requestArg.headers,
+        mode,
+        credentials: 'same-origin',
+        redirect: 'follow'
+      });
+    }
+    return matchRequest;
+  }
+
+  /**
+   * Creates a 500 error response.
+   */
+  private async create500Response(requestArg: Request, responseArg: Response): Promise<Response> {
+    return new Response(
+      `
+      <html>
+        <head>
+          <style>
+            .note {
+              padding: 10px;
+              color: #fff;
+              background: #000;
+              border-bottom: 1px solid #e4002b;
+              margin-bottom: 20px;
+            }
+          </style>
+        </head>
+        <body>
+          <div class="note">
+            <strong>Service worker running, but status 500</strong><br>
+          </div>
+          Service worker is unable to fetch this request.<br>
+          Request URL: ${requestArg.url}<br>
+          Response Type: ${responseArg.type}<br>
+          Response Body: ${await responseArg.clone().text()}<br>
+        </body>
+      </html>
+      `,
+      {
+        headers: { "Content-Type": "text/html" },
+        status: 500
+      }
+    );
+  }
+
+  /**
+   * Sets up the fetch event listener and caching logic.
+   */
+  private _setupCache = () => {
+    this.losslessServiceWorkerRef.serviceWindowRef.addEventListener('fetch', async (fetchEventArg: any) => {
+      const originalRequest: Request = fetchEventArg.request;
+      const parsedUrl = new URL(originalRequest.url);
+
+      // Exclude specific hosts or paths from being handled by the service worker.
+      if (
+        parsedUrl.hostname.includes('paddle.com') ||
+        parsedUrl.hostname.includes('paypal.com') ||
+        parsedUrl.hostname.includes('reception.lossless.one') ||
+        parsedUrl.pathname.startsWith('/socket.io') ||
+        originalRequest.url.startsWith('https://umami.')
+      ) {
+        logger.log('note', `Service worker not active for ${parsedUrl.toString()}`);
+        return;
+      }
+
+      // Create a deferred response.
+      const done = plugins.smartpromise.defer<Response>();
+      fetchEventArg.respondWith(done.promise);
+
+      // Only handle GET requests for caching.
+      if (originalRequest.method === 'GET' && this.isCacheable(originalRequest.url)) {
+        // Determine if the browser is Safari.
+        const userAgent = (self.navigator && self.navigator.userAgent) || "";
+        const isSafari = /Safari/.test(userAgent) && !/Chrome/.test(userAgent);
+
+        // For soft cached domains on Safari, bypass caching entirely.
+        if (this.isSoftCached(originalRequest.url) && isSafari) {
+          logger.log('info', `Safari detected – bypass caching for soft cached domain: ${originalRequest.url}`);
+          const networkResponse = await fetch(originalRequest).catch(async err => {
+            return await this.create500Response(originalRequest, new Response(err.message));
+          });
+          done.resolve(networkResponse);
+          return;
+        }
+
+        // Try to serve from cache.
+        const matchRequest = this.createMatchRequest(originalRequest);
+        const cachedResponse = await caches.match(matchRequest);
+        if (cachedResponse) {
+          logger.log('ok', `CACHED: found cached response for ${matchRequest.url}`);
+          done.resolve(cachedResponse);
+          return;
+        }
+
+        logger.log('info', `NOTYETCACHED: fetching and caching ${matchRequest.url}`);
+        const newResponse: Response = await fetch(matchRequest).catch(async err => {
+          return await this.create500Response(matchRequest, new Response(err.message));
+        });
+
+        // If the response status indicates an error, don't cache.
+        if (newResponse.status > 299) {
+          logger.log('error', `NOTCACHED: response for ${matchRequest.url} has status ${newResponse.status}`);
+          done.resolve(await this.create500Response(matchRequest, newResponse));
+          return;
+        }
+
+        // Handle opaque responses separately.
+        if (newResponse.type === 'opaque') {
+          // For soft-cached domains we expect opaque responses (from no-cors fetches).
+          if (this.isSoftCached(matchRequest.url)) {
+            const cache = await caches.open(this.usedCacheNames.runtimeCacheName);
+            // Cache the opaque response as-is.
+            await cache.put(matchRequest, newResponse.clone());
+            logger.log('ok', `NOWCACHED: cached opaque response for ${matchRequest.url}`);
+            done.resolve(newResponse);
+            return;
+          } else {
+            // If an opaque response comes from a non-soft domain, treat it as an error.
+            logger.log('error', `NOTCACHED: opaque response received for non-soft domain ${matchRequest.url}`);
+            done.resolve(await this.create500Response(matchRequest, newResponse));
+            return;
+          }
+        }
+
+        // For non-opaque responses, adjust headers and cache.
+        const cache = await caches.open(this.usedCacheNames.runtimeCacheName);
+        const responseToCache = newResponse.clone();
+        const headers = new Headers();
+        responseToCache.headers.forEach((value, key) => {
+          // Preserve all headers except caching-related ones.
+          if (!['Cache-Control', 'cache-control', 'Expires', 'expires', 'Pragma', 'pragma'].includes(key)) {
+            headers.set(key, value);
+          }
+        });
+
+        // Ensure necessary CORS headers.
+        if (!headers.has('Access-Control-Allow-Origin')) {
+          headers.set('Access-Control-Allow-Origin', '*');
+        }
+        if (!headers.has('Access-Control-Allow-Methods')) {
+          headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        }
+        if (!headers.has('Access-Control-Allow-Headers')) {
+          headers.set('Access-Control-Allow-Headers', 'Content-Type');
+        }
+        // Prevent browser caching while allowing service worker caching.
+        headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
+        headers.set('Pragma', 'no-cache');
+        headers.set('Expires', '0');
+        headers.set('Surrogate-Control', 'no-store');
+
+        // Read the response body as a blob so we can create a new Response with modified headers.
+        let newCachedResponse: Response;
+        try {
+          const bodyBlob = await responseToCache.blob();
+          newCachedResponse = new Response(bodyBlob, {
+            status: responseToCache.status,
+            statusText: responseToCache.statusText,
+            headers
+          });
+        } catch (err) {
+          newCachedResponse = newResponse;
+        }
+
+        await cache.put(matchRequest, newCachedResponse);
+        logger.log('ok', `NOWCACHED: cached response for ${matchRequest.url}`);
+        done.resolve(newResponse);
+      } else {
+        // For non-cacheable requests, fetch directly from the network.
+        logger.log('ok', `NOTCACHED: fetching ${originalRequest.url} from origin (non-cacheable)`);
+        const networkResponse = await fetch(originalRequest).catch(async err => {
+          return await this.create500Response(originalRequest, new Response(err.message));
+        });
+        done.resolve(networkResponse);
+      }
+    });
+  };
+
+  /**
+   * Cleans all caches.
+   * Should be run when a new service worker is activated.
+   * @param reasonArg A reason for the cache cleanup.
+   */
+  public cleanCaches = async (reasonArg = 'no reason given'): Promise<void> => {
+    logger.log('info', `MAJOR CACHEEVENT: cleaning caches now! Reason: ${reasonArg}`);
+    const cacheNames = await caches.keys();
+
+    const deletePromises = cacheNames.map(cacheToDelete => {
+      const deletePromise = caches.delete(cacheToDelete);
+      deletePromise.then(() => {
+        logger.log('ok', `Deleted cache ${cacheToDelete}`);
+      });
+      return deletePromise;
+    });
+    await Promise.all(deletePromises);
+  };
+
+  /**
+   * Revalidates the runtime cache.
+   */
+  public async revalidateCache(): Promise<void> {
+    const runtimeCache = await caches.open(this.usedCacheNames.runtimeCacheName);
+    const cacheKeys = await runtimeCache.keys();
+    for (const requestArg of cacheKeys) {
+      const clonedRequest = requestArg.clone();
+      const response = await plugins.smartpromise.timeoutWrap(fetch(clonedRequest), 5000);
+      if (response && response.status >= 200 && response.status < 300) {
+        await runtimeCache.delete(requestArg);
+        await runtimeCache.put(requestArg, response);
+      }
+    }
+  }
+}
--- a/ts_web_serviceworker/classes.networkmanager.ts
+++ b/ts_web_serviceworker/classes.networkmanager.ts
@ -0,0 +1,127 @@
+import * as plugins from './plugins.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+import { logger } from './logging.js';
+
+export class NetworkManager {
+  public serviceWorkerRef: ServiceWorker;
+  public webRequest: plugins.webrequest.WebRequest;
+  private isOffline: boolean = false;
+  private lastOnlineCheck: number = 0;
+  private readonly ONLINE_CHECK_INTERVAL = 30000; // 30 seconds
+
+  public previousState: string;
+
+  constructor(serviceWorkerRefArg: ServiceWorker) {
+    this.serviceWorkerRef = serviceWorkerRefArg;
+    this.webRequest = new plugins.webrequest.WebRequest();
+    
+    // Listen for connection changes
+    this.getConnection()?.addEventListener('change', () => {
+      this.updateConnectionStatus();
+    });
+
+    // Listen for online/offline events
+    self.addEventListener('online', () => {
+      this.isOffline = false;
+      logger.log('info', 'Device is now online');
+      this.updateConnectionStatus();
+    });
+
+    self.addEventListener('offline', () => {
+      this.isOffline = true;
+      logger.log('warn', 'Device is now offline');
+      this.updateConnectionStatus();
+    });
+  }
+
+  /**
+   * gets the connection
+   */
+  public getConnection() {
+    const navigatorLocal: any = self.navigator;
+    return navigatorLocal?.connection;
+  }
+
+  public getEffectiveType() {
+    return this.getConnection()?.effectiveType || '4g';
+  }
+
+  public updateConnectionStatus() {
+    const currentType = this.getEffectiveType();
+    logger.log('info', `Connection type changed from ${this.previousState} to ${currentType}`);
+    this.previousState = currentType;
+  }
+
+  /**
+   * Checks if the device is currently online by attempting to contact the server
+   * @returns Promise<boolean> true if online, false if offline
+   */
+  public async checkOnlineStatus(): Promise<boolean> {
+    const now = Date.now();
+    // Only check if enough time has passed since last check
+    if (now - this.lastOnlineCheck < this.ONLINE_CHECK_INTERVAL) {
+      return !this.isOffline;
+    }
+
+    try {
+      const response = await fetch('/sw-typedrequest', {
+        method: 'HEAD',
+        cache: 'no-cache'
+      });
+      this.isOffline = false;
+      this.lastOnlineCheck = now;
+      return true;
+    } catch (error) {
+      this.isOffline = true;
+      this.lastOnlineCheck = now;
+      logger.log('warn', 'Device appears to be offline');
+      return false;
+    }
+  }
+
+  /**
+   * Makes a network request with offline handling
+   * @param request The request to make
+   * @param options Additional options
+   * @returns Promise<Response>
+   */
+  public async makeRequest<T>(request: Request | string, options: {
+    timeoutMs?: number;
+    retries?: number;
+    backoffMs?: number;
+  } = {}): Promise<Response> {
+    const {
+      timeoutMs = 5000,
+      retries = 1,
+      backoffMs = 1000
+    } = options;
+
+    let lastError: Error;
+    for (let i = 0; i <= retries; i++) {
+      try {
+        const isOnline = await this.checkOnlineStatus();
+        if (!isOnline) {
+          throw new Error('Device is offline');
+        }
+
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+        const response = await fetch(request, {
+          ...typeof request === 'string' ? {} : request,
+          signal: controller.signal
+        });
+
+        clearTimeout(timeoutId);
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (i < retries) {
+          await new Promise(resolve => setTimeout(resolve, backoffMs * (i + 1)));
+        }
+      }
+    }
+
+    throw lastError;
+  }
+}
--- a/ts_web_serviceworker/classes.serviceworker.ts
+++ b/ts_web_serviceworker/classes.serviceworker.ts
@ -0,0 +1,76 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './env.js';
+
+// imports
+import { CacheManager } from './classes.cachemanager.js';
+import { Deferred } from '@push.rocks/smartpromise';
+
+import { logger } from './logging.js';
+
+// imported classes
+import { UpdateManager } from './classes.updatemanager.js';
+import { NetworkManager } from './classes.networkmanager.js';
+import { TaskManager } from './classes.taskmanager.js';
+import { ServiceworkerBackend } from './classes.backend.js';
+
+export class ServiceWorker {
+  // STATIC
+
+  // INSTANCE
+  public serviceWindowRef: interfaces.ServiceWindow;
+  public leleServiceWorkerBackend: ServiceworkerBackend;
+
+  public cacheManager: CacheManager;
+
+  public updateManager: UpdateManager;
+  public networkManager: NetworkManager;
+  public taskManager: TaskManager;
+  public store: plugins.webstore.WebStore;
+
+  constructor(selfArg: interfaces.ServiceWindow) {
+    logger.log('info', `Service worker instantiating at ${Date.now()}`);
+    this.serviceWindowRef = selfArg;
+    this.leleServiceWorkerBackend = new ServiceworkerBackend({
+      self: selfArg,
+      purgeCache: async (reqArg) => {
+        await this.cacheManager.cleanCaches(),
+        logger.log('info', `cleaned caches in serviceworker as per request from frontend.`);
+        return {}
+      }
+    });
+
+    this.updateManager = new UpdateManager(this);
+    this.networkManager = new NetworkManager(this);
+    this.taskManager = new TaskManager(this);
+
+    this.cacheManager = new CacheManager(this);
+
+    this.store = new plugins.webstore.WebStore({
+      dbName: 'losslessServiceworker',
+      storeName: 'losslessServiceworker',
+    });
+
+    // =================================
+    // Installation and Activation
+    // =================================
+    this.serviceWindowRef.addEventListener('install', async (event: interfaces.ServiceEvent) => {
+      const done = new Deferred();
+      event.waitUntil(done.promise);
+      // its important to not go async before event.waitUntil
+      done.resolve();
+      logger.log('success', `service worker installed! TimeStamp = ${new Date().toISOString()}`);
+      selfArg.skipWaiting();
+      logger.log('note', `Called skip waiting!`);
+    });
+
+    this.serviceWindowRef.addEventListener('activate', async (event: interfaces.ServiceEvent) => {
+      const done = new Deferred();
+      event.waitUntil(done.promise);
+
+      // its important to not go async before event.waitUntil
+      await selfArg.clients.claim();
+      await this.cacheManager.cleanCaches('new service worker loaded! :)');
+      done.resolve();
+    });
+  }
+}
--- a/ts_web_serviceworker/classes.taskmanager.ts
+++ b/ts_web_serviceworker/classes.taskmanager.ts
@ -0,0 +1,24 @@
+import * as plugins from './plugins.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+
+/**
+ * Taskmanager
+ * should use times allocated by browser
+ */
+export class TaskManager {
+  public serviceworkerRef: ServiceWorker;
+  public taskmanager = new plugins.taskbuffer.TaskManager();
+
+  constructor(serviceWorkerRefArg: ServiceWorker) {
+    this.serviceworkerRef = serviceWorkerRefArg;
+    this.taskmanager.start();
+  }
+
+  public updateTask = new plugins.taskbuffer.Task({
+    name: 'updateTask',
+    taskFunction: async () => {
+      await this.serviceworkerRef.cacheManager.cleanCaches('a new app version has been communicated by the server.');
+    }
+  })
+
+}
--- a/ts_web_serviceworker/classes.typedrequestmanager.ts
+++ b/ts_web_serviceworker/classes.typedrequestmanager.ts
@ -0,0 +1 @@
+import * as plugins from './plugins.js';
--- a/ts_web_serviceworker/classes.updatemanager.ts
+++ b/ts_web_serviceworker/classes.updatemanager.ts
@ -0,0 +1,162 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+import { logger } from './logging.js';
+import { CacheManager } from './classes.cachemanager.js';
+
+export class UpdateManager {
+  public lastUpdateCheck: number = 0;
+  public lastVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'];
+
+  public serviceworkerRef: ServiceWorker;
+
+  constructor(serviceWorkerRefArg: ServiceWorker) {
+    this.serviceworkerRef = serviceWorkerRefArg;
+  }
+
+  /**
+   * checks wether an update is needed
+   */
+  private readonly MAX_CACHE_AGE = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+  private readonly MIN_CHECK_INTERVAL = 100000; // 100 seconds in milliseconds
+  private readonly OFFLINE_GRACE_PERIOD = 7 * 24 * 60 * 60 * 1000; // 7 days grace period when offline
+  private lastCacheTimestamp: number = 0;
+
+  public async checkUpdate(cacheManager: CacheManager): Promise<boolean> {
+    const lswVersionInfoKey = 'versionInfo';
+    const cacheTimestampKey = 'cacheTimestamp';
+
+    // Initialize or load version info
+    if (!this.lastVersionInfo && !(await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
+      this.lastVersionInfo = {
+        appHash: '',
+        appSemVer: 'v0.0.0',
+      };
+    } else if (!this.lastVersionInfo && (await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
+      this.lastVersionInfo = await this.serviceworkerRef.store.get(lswVersionInfoKey);
+    }
+
+    // Load or initialize cache timestamp
+    if (await this.serviceworkerRef.store.check(cacheTimestampKey)) {
+      this.lastCacheTimestamp = await this.serviceworkerRef.store.get(cacheTimestampKey);
+    }
+
+    const now = Date.now();
+    const millisSinceLastCheck = now - this.lastUpdateCheck;
+    const cacheAge = now - this.lastCacheTimestamp;
+
+    // Check if we need to handle stale cache
+    if (cacheAge > this.MAX_CACHE_AGE) {
+      const isOnline = await this.serviceworkerRef.networkManager.checkOnlineStatus();
+      
+      if (isOnline) {
+        logger.log('info', `Cache is older than ${this.MAX_CACHE_AGE}ms, forcing update...`);
+        await this.forceUpdate(cacheManager);
+        return true;
+      } else if (cacheAge > this.OFFLINE_GRACE_PERIOD) {
+        // If we're offline and beyond grace period, warn but continue serving cached content
+        logger.log('warn', `Cache is stale and device is offline. Cache age: ${cacheAge}ms. Using cached content with warning.`);
+        // We could potentially show a warning to the user here
+        return false;
+      } else {
+        logger.log('info', `Cache is stale but device is offline. Within grace period. Using cached content.`);
+        return false;
+      }
+    }
+
+    // Regular update check interval
+    if (millisSinceLastCheck < this.MIN_CHECK_INTERVAL && cacheAge < this.MAX_CACHE_AGE) {
+      return false;
+    }
+    logger.log('info', 'checking for update of the app by comparing app hashes...');
+    this.lastUpdateCheck = now;
+    const currentVersionInfo = await this.getVersionInfoFromServer();
+    logger.log('info', `old versionInfo: ${JSON.stringify(this.lastVersionInfo)}`);
+    logger.log('info', `current versionInfo: ${JSON.stringify(currentVersionInfo)}`);
+    const needsUpdate = this.lastVersionInfo.appHash !== currentVersionInfo.appHash ? true : false;
+    if (needsUpdate) {
+      logger.log('info', 'Caches need to be updated');
+      logger.log('info', 'starting a debounced update task');
+      this.performAsyncUpdateDebouncedTask.trigger();
+      this.lastVersionInfo = currentVersionInfo;
+      await this.serviceworkerRef.store.set(lswVersionInfoKey, this.lastVersionInfo);
+      
+      // Update cache timestamp
+      this.lastCacheTimestamp = now;
+      await this.serviceworkerRef.store.set('cacheTimestamp', now);
+    } else {
+      logger.log('ok', 'caches are still valid, performing revalidation in a bit...');
+      this.performAsyncCacheRevalidationDebouncedTask.trigger();
+      
+      // Update cache timestamp after successful revalidation
+      this.lastCacheTimestamp = now;
+      await this.serviceworkerRef.store.set('cacheTimestamp', now);
+    }
+  }
+
+  /**
+   * gets the apphash from the server
+   */
+  public async getVersionInfoFromServer() {
+    try {
+      const getAppHashRequest = new plugins.typedrequest.TypedRequest<
+        interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo
+      >('/sw-typedrequest', 'serviceworker_versionInfo');
+      
+      // Use networkManager for the request with retries and timeout
+      const response = await this.serviceworkerRef.networkManager.makeRequest('/sw-typedrequest', {
+        timeoutMs: 5000,
+        retries: 2,
+        backoffMs: 1000
+      });
+      
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      logger.log('warn', `Failed to get version info from server: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // tasks
+  /**
+   * this task is executed once we know that there is a new version available
+   */
+  private async forceUpdate(cacheManager: CacheManager) {
+    try {
+      logger.log('info', 'Forcing cache update due to staleness');
+      const currentVersionInfo = await this.getVersionInfoFromServer();
+      
+      // Only proceed with cache cleaning if we successfully got new version info
+      await this.serviceworkerRef.cacheManager.cleanCaches('Cache is stale, forcing update.');
+      this.lastVersionInfo = currentVersionInfo;
+      await this.serviceworkerRef.store.set('versionInfo', this.lastVersionInfo);
+      this.lastCacheTimestamp = Date.now();
+      await this.serviceworkerRef.store.set('cacheTimestamp', this.lastCacheTimestamp);
+      await this.serviceworkerRef.leleServiceWorkerBackend.triggerReloadAll();
+    } catch (error) {
+      logger.log('error', `Failed to force update: ${error.message}. Keeping existing cache.`);
+      // If update fails, we'll keep using the existing cache
+      throw error;
+    }
+  }
+
+  public performAsyncUpdateDebouncedTask = new plugins.taskbuffer.TaskDebounced({
+    name: 'performAsyncUpdate',
+    taskFunction: async () => {
+      logger.log('info', 'trying to update PWA with serviceworker');
+      await this.serviceworkerRef.cacheManager.cleanCaches('a new app version has been communicated by the server.');
+      // lets notify all current clients about the update
+      await this.serviceworkerRef.leleServiceWorkerBackend.triggerReloadAll();
+    },
+    debounceTimeInMillis: 2000,
+  });
+
+  public performAsyncCacheRevalidationDebouncedTask = new plugins.taskbuffer.TaskDebounced({
+    name: 'performAsyncCacheRevalidation',
+    taskFunction: async () => {
+      await this.serviceworkerRef.cacheManager.revalidateCache();
+    },
+    debounceTimeInMillis: 6000
+  });
+}
--- a/ts_web_serviceworker/env.ts
+++ b/ts_web_serviceworker/env.ts
@ -0,0 +1,20 @@
+export * from '../dist_ts_interfaces/index.js';
+
+// =============================
+// Interfaces for the service worker
+// =============================
+// tslint:disable-next-line: interface-name
+export interface ServiceEvent extends Event {
+  request: any;
+  respondWith: any;
+  waitUntil: any;
+}
+
+// tslint:disable-next-line: interface-name
+export interface ServiceWindow extends Window {
+  addEventListener: any;
+  location: any;
+  skipWaiting: any;
+  clients: any;
+}
+declare var self: Window;
--- a/ts_web_serviceworker/index.ts
+++ b/ts_web_serviceworker/index.ts
@ -0,0 +1,7 @@
+// TypeScript declatations
+import * as env from './env.js';
+declare var self: env.ServiceWindow;
+
+import { ServiceWorker } from './classes.serviceworker.js';
+
+const sw = new ServiceWorker(self);
--- a/ts_web_serviceworker/logging.ts
+++ b/ts_web_serviceworker/logging.ts
@ -0,0 +1,17 @@
+import * as smartlog from '@push.rocks/smartlog';
+import { SmartlogDestinationDevtools } from '@push.rocks/smartlog-destination-devtools';
+
+export const logger = new smartlog.Smartlog({
+  logContext: {
+    company: 'Lossless GmbH',
+    companyunit: 'Lossless Cloud',
+    containerName: 'web',
+    environment: 'production',
+    runtime: 'chrome',
+    zone: 'servezone'
+  },
+  minimumLogLevel: 'info'
+});
+
+logger.addLogDestination(new SmartlogDestinationDevtools());
+logger.log('note', 'serviceworker console initialized!');
--- a/ts_web_serviceworker/plugins.ts
+++ b/ts_web_serviceworker/plugins.ts
@ -0,0 +1,25 @@
+// @losslessone_private scope
+import * as interfaces from '../dist_ts_interfaces/index.js';
+
+export { interfaces };
+
+// @apiglobal scope
+import * as typedrequest from '@api.global/typedrequest';
+
+export { typedrequest };
+
+// @pushrocks scope
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as webrequest from '@push.rocks/webrequest';
+import * as webstore from '@push.rocks/webstore';
+import * as taskbuffer from '@push.rocks/taskbuffer';
+
+export { smartdelay, smartpromise, webrequest, webstore, taskbuffer };
+
+// @design.estate scope
+import * as deesComms from '@design.estate/dees-comms';
+
+export {
+  deesComms,
+}
--- a/ts_web_serviceworker_client/00_commitinfo_data.ts
+++ b/ts_web_serviceworker_client/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@losslessone_private/lele-serviceworker',
+  version: '1.0.58',
+  description: 'the mainthread of the serviceworker'
+}
--- a/ts_web_serviceworker_client/classes.actionmanager.ts
+++ b/ts_web_serviceworker_client/classes.actionmanager.ts
@ -0,0 +1,58 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import { logger } from './logging.js';
+
+/**
+ * MessageManager implements two ways of serviceworker communication
+ * * the serviceWorker method
+ * * the deesComms method using BroadcastChannel
+ */
+export class ActionManager {
+  public deesComms = new plugins.deesComms.DeesComms();
+
+  constructor() {
+    // lets define handlers on the client/tab side
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IMessage_Serviceworker_Client_UpdateInfo>('serviceworker_newVersion', async req => {
+      setTimeout(() => {
+        window.location.reload();
+      }, 200);
+      return {};
+    });
+  }
+
+  public async waitForServiceWorkerConnection () {
+    console.log('waiting for service worker connection...')
+    const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Client_Serviceworker_ConnectionPolling>('broadcastConnectionPolling');
+    let connected = false;
+    while (!connected) {
+      tr.fire({
+        tabId: '123'
+      }).then(response => {
+        if (response.serviceworkerId) {
+          console.log('connected to serviceworker!');
+          connected = true;
+        }
+      }).catch();
+      await plugins.smartdelay.delayFor(777);
+      if (!connected) {
+        // lets wake it up.
+        navigator.serviceWorker.controller.postMessage({
+          type: 'wakeUpCall',
+        });
+      }
+    }
+    console.log('ok, got serviceworker connection.')
+  }
+
+  public async purgeServiceWorkerCache () {
+    const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_PurgeServiceWorkerCache>('purgeServiceWorkerCache');
+    const response = await tr.fire({});
+    return response;
+  }
+
+  public async getVersionInfo () {
+    const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>('serviceworker_versionInfo');
+    const response = await tr.fire({});
+    return response;
+  }
+}
--- a/ts_web_serviceworker_client/classes.globalsw.ts
+++ b/ts_web_serviceworker_client/classes.globalsw.ts
@ -0,0 +1,29 @@
+import * as plugins from './plugins.js';
+import { ServiceworkerClient } from './classes.serviceworkerclient.js';
+
+export class GlobalSW {
+  losslessSw: ServiceworkerClient;
+  constructor(losslessServiceWorkerInstanceArg: ServiceworkerClient) {
+    this.losslessSw = losslessServiceWorkerInstanceArg;
+    globalThis.globalSw = this;
+  };
+
+  /**
+   * purges the cache of the app's serviceworker
+   * @returns
+   */
+  public async purgeCache() {
+    await this.losslessSw.actionManager.waitForServiceWorkerConnection();
+    console.log(`purgeCache() was executed via globalThis.globalSw`);
+    const result = await this.losslessSw.actionManager.purgeServiceWorkerCache();
+    return result;
+  }
+
+  /**
+   * attempts to reload the app
+   */
+  public async reloadApp() {
+    await this.purgeCache();
+    window.location.reload();
+  }
+}
--- a/ts_web_serviceworker_client/classes.notificationmanager.ts
+++ b/ts_web_serviceworker_client/classes.notificationmanager.ts
@ -0,0 +1,16 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import { logger } from "./logging.js";
+
+export class NotificationManager {
+
+  constructor() {
+    // this.askPermission();
+  }
+
+  public askPermission () {
+    Notification.requestPermission((status) => {
+      console.log('Notification permission status:', status);
+    });
+  }
+}
--- a/ts_web_serviceworker_client/classes.serviceworkerclient.ts
+++ b/ts_web_serviceworker_client/classes.serviceworkerclient.ts
@ -0,0 +1,69 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import { logger } from "./logging.js";
+import { NotificationManager } from './classes.notificationmanager.js';
+import { ActionManager } from './classes.actionmanager.js';
+import { GlobalSW } from './classes.globalsw.js'
+
+export class ServiceworkerClient {
+  // STATIC
+  public static async createServiceWorker(): Promise<ServiceworkerClient> {
+    if ('serviceWorker' in navigator) {
+      try {
+        logger.log('info', 'trying to register serviceworker');
+        // this is some magic for Parcel to not pick up the serviceworker
+        const serviceworkerInNavigator: ServiceWorkerContainer = navigator.serviceWorker;
+        const swRegistration: ServiceWorkerRegistration = await serviceworkerInNavigator.register('/serviceworker.bundle.js', {
+          scope: '/',
+          updateViaCache: 'none'
+        });
+        plugins.smartdelay.delayFor(2000).then(async () => {
+          swRegistration.onupdatefound = () => {
+            logger.log('info', 'update found for service worker!');
+            logger.log('warn', 'trying to find convenient time to update');
+          };
+          while(true) {
+            await plugins.smartdelay.delayFor(60000);
+            swRegistration.update();
+          }
+        });
+        logger.log('ok', 'serviceworker registered');
+        await navigator.serviceWorker.ready;
+        logger.log('ok', 'serviceworker is ready!');
+        await this.waitForController();
+        const losslessServiceWorkerInstance = new ServiceworkerClient();
+        return losslessServiceWorkerInstance;
+      } catch (err) {
+        // sentry integration here
+        console.log(err);
+        console.log(err.stack);
+      }
+    }
+  }
+
+  private static async waitForController() {
+    const done = new plugins.smartpromise.Deferred();
+    const checkReady = () => {
+      if(navigator.serviceWorker.controller) {
+        logger.log('ok', 'controller is ready');
+        done.resolve();
+      } else {
+        logger.log('warn', 'controller not ready');
+      }
+    };
+    navigator.serviceWorker.oncontrollerchange = checkReady;
+    checkReady();
+    await done.promise;
+  }
+
+  // INSTANCE
+  public notificationManager: NotificationManager;
+  public actionManager: ActionManager;
+  public globalSw: GlobalSW;
+
+  constructor() {
+    this.notificationManager = new NotificationManager();
+    this.actionManager = new ActionManager();
+    this.globalSw = new GlobalSW(this);
+  }
+}
--- a/ts_web_serviceworker_client/index.ts
+++ b/ts_web_serviceworker_client/index.ts
@ -0,0 +1,24 @@
+// types
+import type * as interfaces from '../dist_ts_interfaces/index.js';
+export type {
+  interfaces
+}
+
+// ====================================
+// imports
+// ====================================
+
+import { logger } from './logging.js';
+logger.log('note', 'mainthread console initialized!');
+
+import { ServiceworkerClient } from './classes.serviceworkerclient.js';
+
+export type {
+  ServiceworkerClient
+}
+
+export const getServiceworkerClient = async () => {
+  const swClient = await ServiceworkerClient.createServiceWorker(); // lets setup the service worker
+  logger.log('ok', 'service worker ready!'); // and wait for it to be ready
+  return swClient;
+};
--- a/ts_web_serviceworker_client/logging.ts
+++ b/ts_web_serviceworker_client/logging.ts
@ -0,0 +1,16 @@
+import * as smartlog from '@push.rocks/smartlog';
+import { SmartlogDestinationDevtools } from '@push.rocks/smartlog-destination-devtools';
+
+export const logger = new smartlog.Smartlog({
+  logContext: {
+    company: 'Lossless GmbH',
+    companyunit: 'Lossless Cloud',
+    containerName: 'web',
+    environment: 'production',
+    runtime: 'chrome',
+    zone: 'servezone'
+  },
+  minimumLogLevel: 'info'
+});
+
+logger.addLogDestination(new SmartlogDestinationDevtools());
--- a/ts_web_serviceworker_client/plugins.ts
+++ b/ts_web_serviceworker_client/plugins.ts
@ -0,0 +1,22 @@
+// @apiglobal scope
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
+
+export { typedrequestInterfaces };
+
+// designestate
+import * as deesComms from '@design.estate/dees-comms';
+
+export {
+  deesComms
+};
+
+// @pushrocks scope
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as webstore from '@push.rocks/webstore';
+
+export {
+  smartdelay,
+  smartpromise,
+  webstore
+};
Author	SHA1	Message	Date
Philipp Kunz	0017a559ca	3.0.62	2025-02-04 01:52:48 +01:00
Philipp Kunz	270230b0ca	fix(Service Worker): Refactor and clean up the cache logic in the Service Worker to improve maintainability and handle Safari-specific cache behavior.	2025-02-04 01:52:48 +01:00
Philipp Kunz	6cedd53d61	3.0.61	2025-02-04 01:45:09 +01:00
Philipp Kunz	f518300d68	fix(ServiceWorkerCacheManager): fixed caching	2025-02-04 01:45:08 +01:00
Philipp Kunz	8f6f177d19	3.0.60	2025-02-04 01:36:36 +01:00
Philipp Kunz	4e560a9a51	fix(cachemanager): Improve cache management and error handling	2025-02-04 01:36:35 +01:00
Philipp Kunz	7999e370f6	3.0.59	2025-02-03 23:26:09 +01:00
Philipp Kunz	efade7a78e	fix(serviceworker): Fixed CORS and Cache Control handling for Service Worker	2025-02-03 23:26:08 +01:00
Philipp Kunz	0fecf69420	3.0.58	2025-02-03 00:30:18 +01:00
Philipp Kunz	804537c059	fix(network-manager): Refined network management logic for better offline handling.	2025-02-03 00:30:18 +01:00
Philipp Kunz	aebcbe4a61	3.0.57	2025-02-03 00:25:06 +01:00
Philipp Kunz	c5cb8c1f01	fix(updateManager): Refine cache management for service worker updates.	2025-02-03 00:25:05 +01:00
Philipp Kunz	8202ce6227	3.0.56	2025-02-03 00:16:59 +01:00
Philipp Kunz	4598bd0e25	fix(cachemanager): Adjust cache control headers and fix redundant code	2025-02-03 00:16:58 +01:00
Philipp Kunz	021c980a4f	3.0.55	2025-01-28 10:53:43 +01:00
Philipp Kunz	c7dca75827	fix(server): Fix response content manipulation for HTML files with injectReload	2025-01-28 10:53:42 +01:00
Philipp Kunz	4f7b2888ab	3.0.54	2025-01-28 10:32:17 +01:00
Philipp Kunz	e552a48c02	fix(servertools): Fixed an issue with compression results handling in HandlerStatic where content was always being written even if not compressed.	2025-01-28 10:32:17 +01:00
Philipp Kunz	2ea4139974	3.0.53	2024-12-26 00:09:18 +01:00
Philipp Kunz	e225c693a8	fix(infohtml): Remove Sentry script and logo from HTML template	2024-12-26 00:09:18 +01:00
Philipp Kunz	6393336ea6	3.0.52	2024-12-25 23:57:19 +01:00
Philipp Kunz	d7158734d2	fix(dependencies): Bump package versions in dependencies and exports.	2024-12-25 23:57:18 +01:00
Philipp Kunz	557724718c	3.0.51	2024-08-27 11:22:14 +02:00
Philipp Kunz	d7a9b26873	fix(core): Update dependencies and fix service worker cache manager and task manager functionalities	2024-08-27 11:22:13 +02:00
Philipp Kunz	511de8040a	3.0.50	2024-05-25 03:06:18 +02:00
Philipp Kunz	952e95f82f	fix(core): update	2024-05-25 03:06:17 +02:00
Philipp Kunz	42115cb6be	3.0.49	2024-05-25 03:04:25 +02:00
Philipp Kunz	e1206bdf4c	fix(core): update	2024-05-25 03:04:25 +02:00
Philipp Kunz	e32e7272ba	3.0.48	2024-05-25 02:49:46 +02:00
Philipp Kunz	3f317fffd5	fix(core): update	2024-05-25 02:49:46 +02:00
Philipp Kunz	a49309566c	3.0.47	2024-05-25 02:35:24 +02:00
Philipp Kunz	0fb1d54e06	fix(core): update	2024-05-25 02:35:23 +02:00
Philipp Kunz	f31ca98b2c	3.0.46	2024-05-25 02:34:44 +02:00
Philipp Kunz	dfcda87196	fix(core): update	2024-05-25 02:34:43 +02:00
Philipp Kunz	108bcb41bf	3.0.45	2024-05-25 02:29:09 +02:00
Philipp Kunz	1b18961539	fix(core): update	2024-05-25 02:29:08 +02:00
Philipp Kunz	4fcfd0f52c	3.0.44	2024-05-25 01:28:56 +02:00
Philipp Kunz	8f1464c97e	fix(core): update	2024-05-25 01:28:56 +02:00
Philipp Kunz	96a88911a7	3.0.43	2024-05-25 01:24:03 +02:00
Philipp Kunz	1d5af30e78	fix(core): update	2024-05-25 01:24:02 +02:00
Philipp Kunz	8fe5b6985c	3.0.42	2024-05-23 15:54:34 +02:00
Philipp Kunz	72e02bd611	fix(core): update	2024-05-23 15:54:33 +02:00
Philipp Kunz	fb7c1242a9	3.0.41	2024-05-23 15:28:42 +02:00
Philipp Kunz	360766d8b4	fix(core): update	2024-05-23 15:28:41 +02:00
Philipp Kunz	9968dda0fa	3.0.40	2024-05-23 15:21:47 +02:00
Philipp Kunz	77b9e41bdb	fix(core): update	2024-05-23 15:21:46 +02:00
Philipp Kunz	8bea58b434	3.0.39	2024-05-23 14:54:26 +02:00
Philipp Kunz	bd9397eb13	fix(core): update	2024-05-23 14:54:25 +02:00
Philipp Kunz	6e7316d2b1	3.0.38	2024-05-23 14:51:29 +02:00
Philipp Kunz	cba65bfb81	fix(core): update	2024-05-23 14:51:28 +02:00
Philipp Kunz	f06f25b4db	3.0.37	2024-05-17 17:20:29 +02:00
Philipp Kunz	316625c41b	fix(core): update	2024-05-17 17:20:29 +02:00
Philipp Kunz	ee67c68c17	3.0.36	2024-05-14 15:33:06 +02:00
Philipp Kunz	8fb2d8b3e8	fix(core): update	2024-05-14 15:33:05 +02:00
Philipp Kunz	75c89b040b	3.0.35	2024-05-14 15:28:10 +02:00
Philipp Kunz	b6d0843e3e	fix(core): update	2024-05-14 15:28:09 +02:00
Philipp Kunz	1c5e2845d1	3.0.34	2024-05-14 03:24:03 +02:00
Philipp Kunz	7798bf7e0a	fix(core): update	2024-05-14 03:24:03 +02:00
Philipp Kunz	76db7d1733	3.0.33	2024-05-14 02:18:42 +02:00
Philipp Kunz	1db472ab01	fix(core): update	2024-05-14 02:18:42 +02:00
Philipp Kunz	23e88030be	3.0.32	2024-05-13 23:24:09 +02:00
Philipp Kunz	1644cbbfad	fix(core): update	2024-05-13 23:24:08 +02:00
Philipp Kunz	84e214d087	3.0.31	2024-05-11 12:52:43 +02:00
Philipp Kunz	0bb7e438d5	fix(core): update	2024-05-11 12:52:42 +02:00
Philipp Kunz	1ce6d2ab01	3.0.30	2024-05-11 12:51:21 +02:00
Philipp Kunz	d225a9584f	fix(core): update	2024-05-11 12:51:20 +02:00
Philipp Kunz	fedb37ee16	3.0.29	2024-04-19 01:01:52 +02:00
Philipp Kunz	e99196b227	fix(core): update	2024-04-19 01:01:51 +02:00
Philipp Kunz	3d6723d06c	3.0.28	2024-04-19 01:01:29 +02:00
Philipp Kunz	fd7aadaf79	fix(core): update	2024-04-19 01:01:29 +02:00
Philipp Kunz	5e4878e492	update documentation	2024-04-14 19:00:39 +02:00
Philipp Kunz	64d4fb011d	3.0.27	2024-03-03 10:36:46 +01:00
Philipp Kunz	6671bbe793	fix(core): update	2024-03-03 10:36:45 +01:00
Philipp Kunz	14bfa3f62f	3.0.26	2024-03-01 00:14:34 +01:00
Philipp Kunz	9e4413c276	fix(core): update	2024-03-01 00:14:34 +01:00
Philipp Kunz	dd91691064	3.0.25	2024-02-29 18:58:10 +01:00
Philipp Kunz	bf4794c06f	fix(core): update	2024-02-29 18:58:09 +01:00
Philipp Kunz	7e04474a66	3.0.24	2024-02-24 18:33:33 +01:00
Philipp Kunz	907d51a842	fix(core): update	2024-02-24 18:33:33 +01:00
Philipp Kunz	2114ff28c0	3.0.23	2024-02-21 01:16:39 +01:00
Philipp Kunz	fd9431f82b	fix(core): update	2024-02-21 01:16:39 +01:00