3.0.30

fix(core): update
3.0.29
2024-05-11 12:51:21 +02:00 · 2024-05-11 12:51:20 +02:00 · 2024-04-19 01:01:52 +02:00 · 2024-04-19 01:01:51 +02:00 · 2024-04-19 01:01:29 +02:00 · 2024-04-19 01:01:29 +02:00
64 changed files with 3142 additions and 1551 deletions
--- a/.gitea/workflows/default_tags.yaml
+++ b/.gitea/workflows/default_tags.yaml
@ -105,6 +105,6 @@ jobs:
      run: |
        npmci node install stable
        npmci npm install
-        pnpm install -g @gitzone/tsdoc
+        pnpm install -g @git.zone/tsdoc
        npmci command tsdoc
      continue-on-error: true
--- 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",
-      "npmPackagename": "@apiglobal/typedserver",
-      "license": "MIT"
+      "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",
+      "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,40 @@
 {
-  "name": "@apiglobal/typedserver",
-  "version": "2.0.57",
-  "description": "easy serving of static files",
-  "main": "dist_ts/index.js",
-  "typings": "dist_ts/index.d.ts",
+  "name": "@api.global/typedserver",
+  "version": "3.0.30",
+  "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",
+    "./ts": "./dist_ts/index.js",
+    "./ts_web_inject": "./dist_ts_web_inject/index.js",
+    "./ts_web_serviceworker": "./dist_web_serviceworker",
+    "./ts_web_serviceworker_client": "./dist_web_serviceworker_client"
+  },
  "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 --skiplibcheck && tsbundle --from ./ts_web/index.ts --to ./dist_ts_web/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,41 +55,47 @@
  ],
  "homepage": "https://github.com/pushrocks/easyserve",
  "dependencies": {
-    "@apiglobal/typedrequest": "^2.0.12",
-    "@apiglobal/typedrequest-interfaces": "^2.0.1",
-    "@apiglobal/typedsocket": "^2.0.24",
-    "@pushrocks/lik": "^6.0.2",
-    "@pushrocks/smartchok": "^1.0.23",
-    "@pushrocks/smartdelay": "^3.0.1",
-    "@pushrocks/smartenv": "^5.0.5",
-    "@pushrocks/smartfeed": "^1.0.11",
-    "@pushrocks/smartfile": "^10.0.25",
-    "@pushrocks/smartlog": "^3.0.1",
-    "@pushrocks/smartlog-destination-devtools": "^1.0.10",
-    "@pushrocks/smartmanifest": "^2.0.2",
-    "@pushrocks/smartmime": "^1.0.5",
-    "@pushrocks/smartopen": "^2.0.0",
-    "@pushrocks/smartpath": "^5.0.5",
-    "@pushrocks/smartpromise": "^4.0.2",
-    "@pushrocks/smartrequest": "^2.0.15",
-    "@pushrocks/smartrx": "^3.0.2",
-    "@pushrocks/smartsitemap": "^2.0.1",
-    "@pushrocks/smarttime": "^4.0.1",
-    "@pushrocks/webstore": "^2.0.8",
-    "@tsclass/tsclass": "^4.0.42",
+    "@api.global/typedrequest": "^3.0.23",
+    "@api.global/typedrequest-interfaces": "^3.0.19",
+    "@api.global/typedsocket": "^3.0.1",
+    "@design.estate/dees-comms": "^1.0.24",
+    "@push.rocks/lik": "^6.0.15",
+    "@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.14",
+    "@push.rocks/smartjson": "^5.0.19",
+    "@push.rocks/smartlog": "^3.0.3",
+    "@push.rocks/smartlog-destination-devtools": "^1.0.10",
+    "@push.rocks/smartmanifest": "^2.0.2",
+    "@push.rocks/smartmime": "^1.0.5",
+    "@push.rocks/smartopen": "^2.0.0",
+    "@push.rocks/smartpath": "^5.0.18",
+    "@push.rocks/smartpromise": "^4.0.2",
+    "@push.rocks/smartrequest": "^2.0.22",
+    "@push.rocks/smartrx": "^3.0.7",
+    "@push.rocks/smartsitemap": "^2.0.3",
+    "@push.rocks/smartstream": "^3.0.35",
+    "@push.rocks/smarttime": "^4.0.6",
+    "@push.rocks/taskbuffer": "^3.1.7",
+    "@push.rocks/webrequest": "^3.0.37",
+    "@push.rocks/webstore": "^2.0.14",
+    "@tsclass/tsclass": "^4.0.54",
+    "@types/express": "^4.17.21",
    "body-parser": "^1.20.2",
    "cors": "^2.8.5",
-    "express": "^4.18.2",
+    "express": "^4.19.2",
    "express-force-ssl": "^0.3.2",
-    "lit": "^2.7.5"
+    "lit": "^3.1.3"
  },
  "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.66",
-    "@gitzone/tsbundle": "^2.0.8",
-    "@gitzone/tsrun": "^1.2.42",
-    "@gitzone/tstest": "^1.0.72",
-    "@pushrocks/tapbundle": "^5.0.8",
-    "@types/node": "^20.3.3"
+    "@git.zone/tsbuild": "^2.1.75",
+    "@git.zone/tsbundle": "^2.0.15",
+    "@git.zone/tsrun": "^1.2.44",
+    "@git.zone/tstest": "^1.0.90",
+    "@push.rocks/tapbundle": "^5.0.23",
+    "@types/node": "^20.12.11"
  },
  "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/test/test.reload.ts
+++ b/test/test.reload.ts
@ -1,5 +1,5 @@
-import { tap, expect } from '@pushrocks/tapbundle';
-import * as smartpath from '@pushrocks/smartpath';
+import { tap, expect } from '@push.rocks/tapbundle';
+import * as smartpath from '@push.rocks/smartpath';

 import { TypedServer } from '../ts/index.js';

--- a/test/test.server.ts
+++ b/test/test.server.ts
@ -1,11 +1,11 @@
 // tslint:disable-next-line:no-implicit-dependencies
-import { expect, tap } from '@pushrocks/tapbundle';
+import { expect, tap } from '@push.rocks/tapbundle';

 // helper dependencies
 // tslint:disable-next-line:no-implicit-dependencies

-import * as smartpath from '@pushrocks/smartpath';
-import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartrequest from '@push.rocks/smartrequest';

 import * as typedserver from '../ts/index.js';

@ -27,6 +27,13 @@ tap.test('should create a valid Server', async () => {
    manifest: {
      name: 'Test App',
      short_name: 'testapp',
+      start_url: '/',
+      display: 'standalone',
+      background_color: '#000',
+      theme_color: '#000',
+      scope: '/',
+      lang: 'en',
+      display_override: ['window-controls-overlay'],
    },
    feed: true,
    sitemap: true,
@ -71,7 +78,7 @@ tap.test('should create a valid StaticHandler', async () => {
 });

 tap.test('should add typedrequest and typedsocket', async () => {
-  const typedrequest = await import('@apiglobal/typedrequest');
+  const typedrequest = await import('@api.global/typedrequest');

  const typedrouter = new typedrequest.TypedRouter();
  testServer.addTypedRequest(typedrouter);
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@ -2,7 +2,7 @@
 * autocreated commitinfo by @pushrocks/commitinfo
 */
 export const commitinfo = {
-  name: '@apiglobal/typedserver',
-  version: '2.0.57',
-  description: 'easy serving of static files'
+  name: '@api.global/typedserver',
+  version: '3.0.30',
+  description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,4 +1,4 @@
-import * as plugins from './typedserver.plugins.js';
+import * as plugins from './plugins.js';

 import * as servertools from './servertools/index.js';

--- a/ts/paths.ts
+++ b/ts/paths.ts
@ -0,0 +1,7 @@
+import * as plugins from './plugins.js';
+
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);
+export const distBundleDir = plugins.path.join(packageDir, './dist_bundle');
--- a/ts/plugins.ts
+++ b/ts/plugins.ts
@ -0,0 +1,67 @@
+// node native
+import * as http from 'http';
+import * as https from 'https';
+import * as net from 'net';
+import * as path from 'path';
+import * as stream from 'stream';
+import * as zlib from 'zlib';
+
+export { http, https, net, path, zlib };
+
+// @tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export { tsclass };
+
+// @apiglobal scope
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
+import * as typedsocket from '@api.global/typedsocket';
+
+export { typedrequest, typedrequestInterfaces, typedsocket };
+
+// @pushrocks scope
+import * as lik from '@push.rocks/lik';
+import * as smartchok from '@push.rocks/smartchok';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartfeed from '@push.rocks/smartfeed';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartmanifest from '@push.rocks/smartmanifest';
+import * as smartmime from '@push.rocks/smartmime';
+import * as smartopen from '@push.rocks/smartopen';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartsitemap from '@push.rocks/smartsitemap';
+import * as smartstream from '@push.rocks/smartstream';
+import * as smarttime from '@push.rocks/smarttime';
+
+export {
+  lik,
+  smartchok,
+  smartdelay,
+  smartfeed,
+  smartfile,
+  smartjson,
+  smartmanifest,
+  smartmime,
+  smartopen,
+  smartpath,
+  smartpromise,
+  smartrequest,
+  smartsitemap,
+  smartstream,
+  smarttime,
+  smartrx,
+};
+
+// express
+import bodyParser from 'body-parser';
+import cors from 'cors';
+import express from 'express';
+// @ts-ignore
+import expressForceSsl from 'express-force-ssl';
+
+export { bodyParser, cors, express, expressForceSsl };
--- a/ts/servertools/classes.compressor.ts
+++ b/ts/servertools/classes.compressor.ts
@ -0,0 +1,127 @@
+import * as plugins from '../plugins.js';
+
+export type TCompressionMethod = 'gzip' | 'deflate' | 'br' | 'none';
+export interface ICompressionResult {
+  result: Buffer;
+  compressionMethod: TCompressionMethod;
+}
+
+export class Compressor {
+  private _cache: Map<string, Buffer>;
+  private MAX_CACHE_SIZE: number = 100 * 1024 * 1024; // 100 MB
+
+  constructor() {
+    this._cache = new Map<string, Buffer>();
+  }
+
+  private _addToCache(key: string, value: Buffer) {
+    this._cache.set(key, value);
+    this._manageCacheSize();
+  }
+
+  private _manageCacheSize() {
+    let currentSize = Array.from(this._cache.values()).reduce((acc, buffer) => acc + buffer.length, 0);
+
+    while (currentSize > this.MAX_CACHE_SIZE) {
+      const firstKey = this._cache.keys().next().value;
+      const firstValue = this._cache.get(firstKey)!;
+      currentSize -= firstValue.length;
+      this._cache.delete(firstKey);
+    }
+  }
+
+  public async compressContent(
+    content: Buffer,
+    method: 'gzip' | 'deflate' | 'br' | 'none'
+  ): Promise<Buffer> {
+    const cacheKey = content.toString('base64') + method;
+    const cachedResult = this._cache.get(cacheKey);
+
+    if (cachedResult) {
+      return cachedResult;
+    }
+
+    return new Promise((resolve, reject) => {
+      const callback = (err: Error | null, result: Buffer) => {
+        if (err) reject(err);
+        else {
+          this._addToCache(cacheKey, result);
+          resolve(result);
+        }
+      };
+
+      switch (method) {
+        case 'gzip':
+          plugins.zlib.gzip(content, {
+            level: 1,
+          },callback,);
+          break;
+        case 'br':
+          plugins.zlib.brotliCompress(content, {}, callback);
+          break;
+        case 'deflate':
+          plugins.zlib.deflate(content, callback);
+          break;
+        default:
+          this._addToCache(cacheKey, content);
+          resolve(content);
+      }
+    });
+  }
+
+  public determineCompression(acceptEncoding: string | string[], preferredCompressionMethodsArg: TCompressionMethod[] = []) {
+    // Ensure acceptEncoding is a single string
+    const encodingString = Array.isArray(acceptEncoding)
+      ? acceptEncoding.join(', ')
+      : acceptEncoding;
+
+    let compressionMethod: TCompressionMethod = 'none';
+
+    // Prioritize preferred compression methods if provided
+    for (const preferredMethod of preferredCompressionMethodsArg) {
+      if (new RegExp(`\\b${preferredMethod}\\b`).test(encodingString)) {
+        return preferredMethod;
+      }
+    }
+
+    // Fallback to default prioritization if no preferred method matches
+    if (/\bbr\b/.test(encodingString)) {
+      compressionMethod = 'br';
+    } else if (/\bgzip\b/.test(encodingString)) {
+      compressionMethod = 'gzip';
+    } else if (/\bdeflate\b/.test(encodingString)) {
+      compressionMethod = 'deflate';
+    }
+
+    return compressionMethod;
+  }
+
+  public async maybeCompress(requestHeaders: plugins.http.IncomingHttpHeaders, content: Buffer, preferredCompressionMethodsArg?: TCompressionMethod[]): Promise<ICompressionResult> {
+    const acceptEncoding = requestHeaders['accept-encoding'];
+    const compressionMethod = this.determineCompression(acceptEncoding, preferredCompressionMethodsArg);
+    const result = await this.compressContent(content, compressionMethod);
+    return {
+      result,
+      compressionMethod,
+    };
+  }
+
+  public createCompressionStream(method: 'gzip' | 'deflate' | 'br' | 'none') {
+    let compressionStream: any;
+    switch (method) {
+      case 'gzip':
+        compressionStream = plugins.zlib.createGzip();
+      case 'br':
+        compressionStream = plugins.zlib.createBrotliCompress({
+          chunkSize: 16 * 1024,
+          params: {
+            
+          },
+        });
+      case 'deflate':
+        compressionStream = plugins.zlib.createDeflate();
+      default:
+        compressionStream = plugins.smartstream.createPassThrough();
+    }
+  }
+}
--- a/ts/servertools/classes.feed.ts
+++ b/ts/servertools/classes.feed.ts
@ -1,6 +1,6 @@
 import { Handler } from './classes.handler.js';
 import { Server } from './classes.server.js';
-import * as plugins from '../typedserver.plugins.js';
+import * as plugins from '../plugins.js';

 export class Feed {
  public smartexpressRef: Server;
--- a/ts/servertools/classes.handler.ts
+++ b/ts/servertools/classes.handler.ts
@ -1,5 +1,5 @@
-import * as plugins from '../typedserver.plugins.js';
-import { Request, Response } from 'express';
+import * as plugins from '../plugins.js';
+import { type Request, type Response } from 'express';

 export interface IHandlerFunction {
  (requestArg: Request, responseArg: Response): void;
--- a/ts/servertools/classes.handlerproxy.ts
+++ b/ts/servertools/classes.handlerproxy.ts
@ -1,7 +1,7 @@
-import * as plugins from '../typedserver.plugins.js';
+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 {
  /**
@ -40,7 +40,7 @@ export class HandlerProxy extends Handler {
        }
      }

-      let responseToSend: string = proxiedResponse.body;
+      let responseToSend: Buffer = proxiedResponse.body;
      if (typeof responseToSend !== 'string') {
        console.log(proxyRequestUrl);
        console.log(responseToSend);
--- a/ts/servertools/classes.handlerstatic.ts
+++ b/ts/servertools/classes.handlerstatic.ts
@ -1,9 +1,11 @@
-import * as plugins from '../typedserver.plugins.js';
-import * as interfaces from '../interfaces/index.js';
+import * as plugins from '../plugins.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';

 export class HandlerStatic extends Handler {
+  public compressor = new Compressor();
  constructor(
    pathArg: string,
    optionsArg?: {
@ -11,6 +13,8 @@ export class HandlerStatic extends Handler {
      responseModifier?: interfaces.TResponseModifier;
      headers?: { [key: string]: string };
      serveIndexHtmlDefault?: boolean;
+      enableCompression?: boolean;
+      preferredCompressionMethod?: TCompressionMethod;
    }
  ) {
    super('GET', async (req, res) => {
@ -62,11 +66,9 @@ export class HandlerStatic extends Handler {
      }

      // lets actually care about serving, if security checks pass
-      let fileString: string;
-      let fileEncoding: 'binary' | 'utf8';
+      let fileBuffer: Buffer;
      try {
-        fileString = plugins.smartfile.fs.toStringSync(joinedPath);
-        fileEncoding = plugins.smartmime.getEncoding(joinedPath);
+        fileBuffer = plugins.smartfile.fs.toBufferSync(joinedPath);
        usedPath = joinedPath;
      } catch (err) {
        // try serving index.html instead
@ -75,8 +77,7 @@ export class HandlerStatic extends Handler {
          console.log(`serving default path ${defaultPath} instead of ${joinedPath}`);
          try {
            parsedPath = plugins.path.parse(defaultPath);
-            fileString = plugins.smartfile.fs.toStringSync(defaultPath);
-            fileEncoding = plugins.smartmime.getEncoding(defaultPath);
+            fileBuffer = plugins.smartfile.fs.toBufferSync(defaultPath);
            usedPath = defaultPath;
          } catch (err) {
            res.writeHead(500);
@ -99,7 +100,7 @@ export class HandlerStatic extends Handler {
        const modifiedResponse = await optionsArg.responseModifier({
          headers: res.getHeaders(),
          path: usedPath,
-          responseContent: fileString,
+          responseContent: fileBuffer,
          travelData,
        });

@ -115,11 +116,26 @@ export class HandlerStatic extends Handler {
        }

        // responseContent
-        fileString = modifiedResponse.responseContent;
+        fileBuffer = modifiedResponse.responseContent;
+      }
+
+      // lets finally deal with compression
+      let compressionResult: ICompressionResult;
+
+      if (optionsArg && optionsArg.enableCompression) {
+        compressionResult = await this.compressor.maybeCompress(requestHeaders, fileBuffer, [optionsArg.preferredCompressionMethod]);
+      } else {
+        compressionResult = {
+          compressionMethod: 'none',
+          result: fileBuffer,
+        };
      }

      res.status(200);
-      res.write(Buffer.from(fileString, fileEncoding));
+      if (compressionResult?.compressionMethod) {
+        res.header('Content-Encoding', compressionResult.compressionMethod);
+      }
+      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 '../typedserver.plugins.js';
+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(response);
+      res.type('json');
+      res.write(plugins.smartjson.stringify(response));
+      res.end();
    });
  }
 }
--- a/ts/servertools/classes.route.ts
+++ b/ts/servertools/classes.route.ts
@ -1,14 +1,13 @@
-import * as plugins from '../typedserver.plugins.js';
+import * as plugins from '../plugins.js';
 import { Handler } from './classes.handler.js';
 import { Server } from './classes.server.js';

-import { ObjectMap } from '@pushrocks/lik';
-import { IRoute as IExpressRoute } from 'express';
+import { type IRoute as IExpressRoute } from 'express';

 export class Route {
  public routeString: string;
-  public handlerObjectMap = new ObjectMap<Handler>();
-  public expressMiddlewareObjectMap = new ObjectMap<any>();
+  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) {
    this.routeString = routeStringArg;
--- a/ts/servertools/classes.server.ts
+++ b/ts/servertools/classes.server.ts
@ -1,4 +1,4 @@
-import * as plugins from '../typedserver.plugins.js';
+import * as plugins from '../plugins.js';

 import { Route } from './classes.route.js';
 import { Handler } from './classes.handler.js';
@ -105,7 +105,6 @@ export class Server {

    // general request handlling
    this.expressAppInstance.use((req, res, next) => {
-      req.setTimeout(60 * 1000);
      next();
    });

@ -133,7 +132,8 @@ export class Server {

    this.expressAppInstance.use((req, res, next) => {
      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
-      res.setHeader('Cross-Origin-Embedder-Policy', 'unsafe-none');
+      res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
+      res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
      res.setHeader('Access-Control-Allow-Origin', '*');
      res.setHeader('SERVEZONE_ROUTE', 'LOSSLESS_ORIGIN_CONTAINER');
      res.setHeader('Cache-Control', 'no-cache');
@ -142,7 +142,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
@ -219,25 +236,47 @@ export class Server {
    this.httpServer.on('connection', (connection: plugins.net.Socket) => {
      this.socketMap.add(connection);
      console.log(`added connection. now ${this.socketMap.getArray().length} sockets connected.`);
-      const cleanupConnection = () => {
+      
+      const closeListener = () => {
+        console.log('connection closed');
+        cleanupConnection();
+      };
+      
+      const errorListener = () => {
+        console.log('connection errored');
+        cleanupConnection();
+      };
+      
+      const endListener = () => {
+        console.log('connection ended');
+        cleanupConnection();
+      };
+      
+      const timeoutListener = () => {
+        console.log('connection timed out');
+        cleanupConnection();
+      };
+      
+      connection.addListener('close', closeListener);
+      connection.addListener('error', errorListener);
+      connection.addListener('end', endListener);
+      connection.addListener('timeout', timeoutListener);
+      
+      const cleanupConnection = async () => {
+        connection.removeListener('close', closeListener);
+        connection.removeListener('error', errorListener);
+        connection.removeListener('end', endListener);
+        connection.removeListener('timeout', timeoutListener);
+        
        if (this.socketMap.checkForObject(connection)) {
          this.socketMap.remove(connection);
          console.log(`removed connection. ${this.socketMap.getArray().length} sockets remaining.`);
-          connection.destroy();
+          await plugins.smartdelay.delayFor(0);
+          if (connection.destroyed === false) {
+            connection.destroy();
+          }
        }
      };
-      connection.on('close', () => {
-        cleanupConnection();
-      });
-      connection.on('error', () => {
-        cleanupConnection();
-      });
-      connection.on('end', () => {
-        cleanupConnection();
-      });
-      connection.on('timeout', () => {
-        cleanupConnection();
-      });
    });

    // finally listen on a port
--- a/ts/servertools/classes.sitemap.ts
+++ b/ts/servertools/classes.sitemap.ts
@ -1,7 +1,7 @@
 import { Server } from './classes.server.js';
 import { Handler } from './classes.handler.js';
-import * as plugins from '../typedserver.plugins.js';
-import { type IUrlInfo } from '@pushrocks/smartsitemap';
+import * as plugins from '../plugins.js';
+import { type IUrlInfo } from '@push.rocks/smartsitemap';

 export class Sitemap {
  public smartexpressRef: Server;
--- a/ts/servertools/tools.manifest.ts
+++ b/ts/servertools/tools.manifest.ts
@ -1,4 +1,4 @@
-import * as plugins from '../typedserver.plugins.js';
+import * as plugins from '../plugins.js';

 export const setupManifest = async (
  expressInstanceArg: plugins.express.Application,
--- a/ts/servertools/tools.robots.ts
+++ b/ts/servertools/tools.robots.ts
@ -1,4 +1,4 @@
-import * as plugins from '../typedserver.plugins.js';
+import * as plugins from '../plugins.js';
 import { Server } from './classes.server.js';
 import { Handler } from './classes.handler.js';

--- 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 '../typedserver.classes.typedserver.js';
+import { HandlerTypedRouter } from './classes.handlertypedrouter.js';
+
+const lswJS: string = plugins.smartfile.fs.toStringSync(
+  plugins.path.join(paths.distBundleDir, './lsw.js')
+);
+const lswJSMeta: string = plugins.smartfile.fs.toStringSync(
+  plugins.path.join(paths.distBundleDir, './lsw.js.map')
+);
+let lswVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
+  null;
+const serviceworkerHandler = new Handler(
+  'GET',
+  async (req, res) => {
+    if (req.path === '/lsw.js') {
+      res.status(200);
+      res.set('Content-Type', 'text/javascript');
+      res.write(lswJS + '\n' + `/** appSemVer: ${lswVersionInfo?.appSemVer || 'not set'} */`);
+    } else if (req.path === '/lsw.js.map') {
+      res.status(200);
+      res.set('Content-Type', 'application/json');
+      res.write(lswJSMeta);
+    }
+    res.end();
+  }
+);
+
+export const addServiceWorkerRoute = (
+  typedserverInstance: TypedServer,
+  lswData: () => interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response']
+) => {
+  // lets the version info as unique string;
+  lswVersionInfo = lswData();
+
+  // the basic stuff
+  typedserverInstance.server.addRoute('/lsw.js*', 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 = lswData();
+        return versionInfoResponse;
+      }
+    )
+  );
+
+  typedserverInstance.server.addRoute(
+    '/lsw-typedrequest',
+    new HandlerTypedRouter(typedrouter)
+  );
+};
--- a/ts/servertools/tools.sslredirect.ts
+++ b/ts/servertools/tools.sslredirect.ts
@ -1,4 +1,4 @@
-import * as plugins from '../typedserver.plugins.js';
+import * as plugins from '../plugins.js';
 import { Server } from './classes.server.js';
 import { Handler } from './classes.handler.js';

--- a/ts/typedserver.classes.typedserver.ts
+++ b/ts/typedserver.classes.typedserver.ts
@ -1,7 +1,8 @@
-import * as plugins from './typedserver.plugins.js';
+import * as plugins from './plugins.js';
 import * as paths from './typedserver.paths.js';
-import * as interfaces from './interfaces/index.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';

 export interface IServerOptions {
  /**
@ -14,6 +15,16 @@ export interface IServerOptions {
   */
  injectReload?: boolean;

+  /**
+   * enable compression
+   */
+  enableCompression?: boolean;
+
+  /**
+   * choose a preferred compression method
+   */
+  preferredCompressionMethod?: TCompressionMethod;
+
  /**
   * watch the serve directory?
   */
@ -109,6 +120,10 @@ export class TypedServer {
        }
      })
    );
+    this.server.addRoute(
+      '/typedrequest',
+      new servertools.HandlerTypedRouter(this.typedrouter)
+    )
  }

  /**
@ -120,7 +135,7 @@ export class TypedServer {
        '/*',
        new servertools.HandlerStatic(this.options.serveDir, {
          responseModifier: async (responseArg) => {
-            let fileString = responseArg.responseContent;
+            let fileString = responseArg.responseContent.toString();
            if (plugins.path.parse(responseArg.path).ext === '.html') {
              const fileStringArray = fileString.split('<head>');
              if (this.options.injectReload && fileStringArray.length === 2) {
@ -149,10 +164,12 @@ export class TypedServer {
            return {
              headers,
              path: responseArg.path,
-              responseContent: fileString,
+              responseContent: Buffer.from(fileString),
            };
          },
          serveIndexHtmlDefault: true,
+          enableCompression: this.options.enableCompression,
+          preferredCompressionMethod: this.options.preferredCompressionMethod,
        })
      );
    } else if (this.options.injectReload) {
@ -161,7 +178,7 @@ export class TypedServer {
      );
    }
    if (this.options.watch && this.options.serveDir) {
-      this.smartchokInstance = new plugins.smartchok.Smartchok([this.options.serveDir], {});
+      this.smartchokInstance = new plugins.smartchok.Smartchok([this.options.serveDir]);
      await this.smartchokInstance.start();
      (await this.smartchokInstance.getObservableFor('change')).subscribe(async () => {
        await this.createServeDirHash();
--- a/ts/typedserver.paths.ts
+++ b/ts/typedserver.paths.ts
@ -1,4 +1,4 @@
-import * as plugins from './typedserver.plugins.js';
+import * as plugins from './plugins.js';

 export const packageDir = plugins.path.join(
  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
--- a/ts/typedserver.plugins.ts
+++ b/ts/typedserver.plugins.ts
@ -1,61 +0,0 @@
-// node native
-import * as http from 'http';
-import * as https from 'https';
-import * as net from 'net';
-import * as path from 'path';
-
-export { http, https, net, path };
-
-// @tsclass scope
-import * as tsclass from '@tsclass/tsclass';
-
-export { tsclass };
-
-// @apiglobal scope
-import * as typedrequest from '@apiglobal/typedrequest';
-import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
-import * as typedsocket from '@apiglobal/typedsocket';
-
-export { typedrequest, typedrequestInterfaces, typedsocket };
-
-// @pushrocks scope
-import * as lik from '@pushrocks/lik';
-import * as smartchok from '@pushrocks/smartchok';
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartfeed from '@pushrocks/smartfeed';
-import * as smartfile from '@pushrocks/smartfile';
-import * as smartmanifest from '@pushrocks/smartmanifest';
-import * as smartmime from '@pushrocks/smartmime';
-import * as smartopen from '@pushrocks/smartopen';
-import * as smartpath from '@pushrocks/smartpath';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartrequest from '@pushrocks/smartrequest';
-import * as smartrx from '@pushrocks/smartrx';
-import * as smartsitemap from '@pushrocks/smartsitemap';
-import * as smarttime from '@pushrocks/smarttime';
-
-export {
-  lik,
-  smartchok,
-  smartdelay,
-  smartfeed,
-  smartfile,
-  smartmanifest,
-  smartmime,
-  smartopen,
-  smartpath,
-  smartpromise,
-  smartrequest,
-  smartsitemap,
-  smarttime,
-  smartrx,
-};
-
-// express
-import bodyParser from 'body-parser';
-import cors from 'cors';
-import express from 'express';
-// @ts-ignore
-import expressForceSsl from 'express-force-ssl';
-
-export { bodyParser, cors, express, expressForceSsl };
--- 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
@ -1,11 +1,11 @@
 export type TResponseModifier = <T>(responseArg: {
  headers: { [header: string]: number | string | string[] | undefined };
  path: string;
-  responseContent: string;
+  responseContent: Buffer;
  travelData?: T;
 }) => Promise<{
  headers: { [header: string]: number | string | string[] | undefined };
  path: string;
-  responseContent: string;
+  responseContent: Buffer;
  travelData?: T;
 }>;
--- 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
@ -1,4 +1,5 @@
-import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
+// not using the global plugins here to support better bundling...
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';

 export interface IReq_PushLatestServerChangeTime
  extends typedrequestInterfaces.implementsTR<
--- 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: '@apiglobal/typedserver',
-  version: '2.0.57',
-  description: 'easy serving of static files'
-}
--- a/ts_web/typedserver_web.plugins.ts
+++ b/ts_web/typedserver_web.plugins.ts
@ -1,21 +0,0 @@
-// @apiglobal scope
-import * as typedrequest from '@apiglobal/typedrequest';
-import * as typedsocket from '@apiglobal/typedsocket';
-
-export {
-  typedrequest,
-  typedsocket,
-}
-
-// pushrocks scope
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartlog from '@pushrocks/smartlog';
-import * as smartlogDestinationDevtools from '@pushrocks/smartlog-destination-devtools';
-import * as webstore from '@pushrocks/webstore';
-
-export  {
-  smartdelay,
-  smartlog,
-  smartlogDestinationDevtools,
-  webstore,
-};
--- 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 '../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
@ -0,0 +1,21 @@
+// @apiglobal scope
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedsocket from '@api.global/typedsocket';
+
+export {
+  typedrequest,
+  typedsocket,
+}
+
+// pushrocks scope
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartlogDestinationDevtools from '@push.rocks/smartlog-destination-devtools';
+import * as webstore from '@push.rocks/webstore';
+
+export  {
+  smartdelay,
+  smartlog,
+  smartlogDestinationDevtools,
+  webstore,
+};
--- 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/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,8 @@
+// TypeScript declatations
+import * as env from './env.js';
+declare var self: env.ServiceWindow;
+
+import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
+
+const losslessServiceWorkerInstance = new LosslessServiceWorker(self);
+
--- 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/serviceworker.classes.cachemanager.ts
+++ b/ts_web_serviceworker/serviceworker.classes.cachemanager.ts
@ -0,0 +1,224 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './env.js';
+import { logger } from './serviceworker.logging.js';
+import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
+
+export class CacheManager {
+  public losslessServiceWorkerRef: LosslessServiceWorker;
+
+  public usedCacheNames = {
+    runtimeCacheName: 'runtime'
+  };
+
+  constructor(losslessServiceWorkerRefArg: LosslessServiceWorker) {
+    this.losslessServiceWorkerRef = losslessServiceWorkerRefArg;
+    this._setupCache();
+  }
+
+  private _setupCache = () => {
+    const createMatchRequest = (requestArg: Request) => {
+      // lets create a matchRequest
+      let matchRequest: Request;
+      if (requestArg.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin)) {
+        // internal request
+        matchRequest = requestArg;
+      } else {
+        matchRequest = new Request(requestArg.url, {
+          ...requestArg.clone(),
+          mode: 'cors'
+        });
+      }
+      return matchRequest;
+    };
+  
+    /**
+     * creates a 500 response
+     */
+    const create500Response = async (requestArg: Request, responseArg: 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>serviceworker running, but status 500</strong><br>
+          </div>
+          serviceworker is unable to fetch this request<br>
+          Here is some info about the request/response pair:<br>
+          <br>
+          requestUrl: ${requestArg.url}<br>
+          responseType: ${responseArg.type}<br>
+          responseBody: ${await responseArg.clone().text()}<br>
+          </body>
+        </html>
+      `,
+        {
+          headers: {
+            "Content-Type": "text/html"
+          },
+          status: 500
+        }
+      );
+    };
+  
+    // A list of local resources we always want to be cached.
+    this.losslessServiceWorkerRef.serviceWindowRef.addEventListener('fetch', async (fetchEventArg: any) => {
+      // Lets block scopes we don't want to be passing through the serviceworker
+      const parsedUrl = new URL(fetchEventArg.request.url)
+      if (
+        parsedUrl.hostname.includes('paddle.com')
+        || parsedUrl.hostname.includes('paypal.com')
+        || parsedUrl.hostname.includes('reception.lossless.one')
+        || parsedUrl.pathname.startsWith('/socket.io')
+      ) {
+        logger.log('note',`serviceworker not active for ${parsedUrl.toString()}`);
+        return;
+      }
+      
+      // lets continue for the rest
+      const done = plugins.smartpromise.defer<Response>();
+      fetchEventArg.respondWith(done.promise);
+      const originalRequest: Request = fetchEventArg.request;
+  
+      if (
+        (originalRequest.method === 'GET' &&
+          (originalRequest.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin) &&
+            !originalRequest.url.includes('/api/') &&
+            !originalRequest.url.includes('smartserve/reloadcheck'))) ||
+        originalRequest.url.includes('https://assetbroker.lossless.one/public') ||
+        originalRequest.url.includes('https://assetbroker.lossless.one/brandfiles') ||
+        originalRequest.url.includes('https://assetbroker.lossless.one/websites') ||
+        originalRequest.url.includes('https://unpkg.com') ||
+        originalRequest.url.includes('https://fonts.googleapis.com') ||
+        originalRequest.url.includes('https://fonts.gstatic.com')
+      ) {
+  
+        // lets see if things need to be updated
+        // not waiting here
+        this.losslessServiceWorkerRef.updateManager.checkUpdate(this);
+  
+        // this code block is executed for local requests
+        const matchRequest = createMatchRequest(originalRequest);
+        const cachedResponse = await caches.match(matchRequest);
+        if (cachedResponse) {
+          logger.log('ok', `CACHED: found cached response for ${matchRequest.url}`);
+          done.resolve(cachedResponse);
+          return;
+        }
+  
+        // in case there is no cached response
+        logger.log('info', `NOTYETCACHED: trying to cache ${matchRequest.url}`);
+        const newResponse: Response = await fetch(matchRequest).catch(async err => {
+          return await create500Response(matchRequest, new Response(err.message));
+        });
+  
+        // fill cache
+        // Put a copy of the response in the runtime cache.
+        if (newResponse.status > 299 || newResponse.type === 'opaque') {
+          logger.log(
+            'error',
+            `NOTCACHED: can't cache response for ${matchRequest.url} due to status ${
+              newResponse.status
+            } and type ${newResponse.type}`
+          );
+          done.resolve(await create500Response(matchRequest, newResponse));
+        } else {
+          const cache = await caches.open(this.usedCacheNames.runtimeCacheName);
+          const responseToPutToCache = newResponse.clone();
+          const headers = new Headers();
+          responseToPutToCache.headers.forEach((value, key) => {
+            if (
+              value !== 'Cache-Control'
+              && value !== 'cache-control'
+              && value !== 'Expires'
+              && value !== 'expires'
+              && value !== 'Pragma'
+              && value !== 'pragma'
+            ) {
+              headers.set(key, value);
+            }
+          });
+          headers.set('Cache-Control', 'no-cache, no-store, must-revalidate');
+          headers.set('Pragma', 'no-cache');
+          headers.set('Expires', '0');
+          await cache.put(matchRequest, new Response(responseToPutToCache.body, {
+            ...responseToPutToCache,
+            headers
+          }));
+          logger.log(
+            'ok',
+            `NOWCACHED: cached response for ${matchRequest.url} for subsequent requests!`
+          );
+          done.resolve(newResponse);
+        }
+      } else {
+        // this code block is executed for remote requests
+        logger.log(
+          'ok',
+          `NOTCACHED: not caching any responses for ${
+            originalRequest.url
+          }. Fetching from origin now...`
+        );
+        done.resolve(
+          await fetch(originalRequest).catch(async err => {
+            return await create500Response(originalRequest, new Response(err.message));
+          })
+        );
+      }
+    });
+  }
+
+  /**
+   * update caches
+   * @param reasonArg
+   */
+
+  /**
+   * cleans all caches
+   * should only be run when running a new service worker
+   * @param reasonArg
+   */
+  public cleanCaches = async (reasonArg = 'no reason given') => {
+    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);
+  }
+
+  /**
+   * revalidate cache
+   */
+  public async revalidateCache() {
+    const runtimeCache = await caches.open(this.usedCacheNames.runtimeCacheName);
+    const cacheKeys = await runtimeCache.keys();
+    for (const requestArg of cacheKeys) {
+      const cachedResponse = runtimeCache.match(requestArg);
+
+      // lets get a new response for comparison
+      const clonedRequest = requestArg.clone();
+      const response = await plugins.smartpromise.timeoutWrap(fetch(clonedRequest), 1000);
+      if (response && response.status >= 200 && response.status < 300) {
+        await runtimeCache.delete(requestArg);
+        await runtimeCache.put(requestArg, response);
+      }
+    }
+  }
+}
--- a/ts_web_serviceworker/serviceworker.classes.networkmanager.ts
+++ b/ts_web_serviceworker/serviceworker.classes.networkmanager.ts
@ -0,0 +1,33 @@
+import * as plugins from './plugins.js';
+import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
+
+export class NetworkManager {
+  public serviceWorkerRef: LosslessServiceWorker;
+  public webRequest: plugins.webrequest.WebRequest;
+
+  public previousState: string;
+
+  constructor(serviceWorkerRefArg: LosslessServiceWorker) {
+    this.serviceWorkerRef = serviceWorkerRefArg;
+    this.webRequest = new plugins.webrequest.WebRequest();
+    this.getConnection()?.addEventListener('change', () => {
+      this.updateConnectionStatus();
+    });
+  }
+
+  /**
+   * gets the connection
+   */
+  public getConnection() {
+    const navigatorLocal: any = self.navigator;
+    return navigatorLocal?.connection;
+  }
+
+  public getEffectiveType() {
+    return this.getConnection()?.effectiveType || '4g';
+  }
+
+  public updateConnectionStatus() {
+    console.log(`Connection type changed from ${this.previousState} to ${this.getEffectiveType()}`);
+  }
+}
--- a/ts_web_serviceworker/serviceworker.classes.serviceworker.ts
+++ b/ts_web_serviceworker/serviceworker.classes.serviceworker.ts
@ -0,0 +1,75 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './env.js';
+
+// imports
+import { CacheManager } from './serviceworker.classes.cachemanager.js';
+import { Deferred } from '@push.rocks/smartpromise';
+
+import { logger } from './serviceworker.logging.js';
+
+// imported classes
+import { UpdateManager } from './serviceworker.classes.updatemanager.js';
+import { NetworkManager } from './serviceworker.classes.networkmanager.js';
+import { TaskManager } from './serviceworker.classes.taskmanager.js';
+
+export class LosslessServiceWorker {
+  // STATIC
+
+  // INSTANCE
+  public serviceWindowRef: interfaces.ServiceWindow;
+  public leleServiceWorkerBackend: plugins.leleServiceworker.LosslessServiceworkerBackend;
+
+  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 = plugins.leleServiceworker.getServiceWorkerBackend({
+      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/serviceworker.classes.taskmanager.ts
+++ b/ts_web_serviceworker/serviceworker.classes.taskmanager.ts
@ -0,0 +1,15 @@
+import * as plugins from './plugins.js';
+import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
+
+/**
+ * Taskmanager
+ * should use times allocated by browser
+ */
+export class TaskManager {
+  public serviceworkerRef: LosslessServiceWorker;
+
+  constructor(serviceWorkerRefArg: LosslessServiceWorker) {
+    this.serviceworkerRef = serviceWorkerRefArg;
+  }
+
+}
--- a/ts_web_serviceworker/serviceworker.classes.typedrequestmanager.ts
+++ b/ts_web_serviceworker/serviceworker.classes.typedrequestmanager.ts
@ -0,0 +1 @@
+import * as plugins from './plugins.js';
--- a/ts_web_serviceworker/serviceworker.classes.updatemanager.ts
+++ b/ts_web_serviceworker/serviceworker.classes.updatemanager.ts
@ -0,0 +1,90 @@
+import * as plugins from './plugins.js';
+import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
+import { logger } from './serviceworker.logging.js';
+import { CacheManager } from './serviceworker.classes.cachemanager.js';
+
+export class UpdateManager {
+  public lastUpdateCheck: number = 0;
+  public lastVersionInfo: plugins.lointServiceworker.IRequest_Serviceworker_Backend_VersionInfo['response'];
+
+  public serviceworkerRef: LosslessServiceWorker;
+
+  constructor(serviceWorkerRefArg: LosslessServiceWorker) {
+    this.serviceworkerRef = serviceWorkerRefArg;
+  }
+
+  /**
+   * checks wether an update is needed
+   */
+  public async checkUpdate(cacheManager: CacheManager): Promise<boolean> {
+    const lswVersionInfoKey = 'versionInfo';
+    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);
+    }
+
+    const now = Date.now();
+    const millisSinceLastCheck = now - this.lastUpdateCheck;
+    if (millisSinceLastCheck < 100000) {
+      // TODO account for being offline
+      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);
+    } else {
+      logger.log('ok', 'caches are still valid, performing revalidation in a bit...');
+      this.performAsyncCacheRevalidationDebouncedTask.trigger();
+    }
+  }
+
+  /**
+   * gets the apphash from the server
+   */
+  public async getVersionInfoFromServer() {
+    const getAppHashRequest = new plugins.typedrequest.TypedRequest<
+      plugins.lointServiceworker.IRequest_Serviceworker_Backend_VersionInfo
+    >('/lsw-typedrequest', 'serviceworker_versionInfo');
+    const result = await getAppHashRequest.fire({});
+    return result;
+  }
+
+  // tasks
+  /**
+   * this task is executed once we know that there is a new version available
+   */
+  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/serviceworker.logging.ts
+++ b/ts_web_serviceworker/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_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/index.ts
+++ b/ts_web_serviceworker_client/index.ts
@ -0,0 +1,24 @@
+// types
+import type * as interfaces from './interfaces/index.js';
+export type {
+  interfaces
+}
+
+// ====================================
+// imports
+// ====================================
+
+import { logger } from './serviceworker.logging.js';
+logger.log('note', 'mainthread console initialized!');
+
+import { LosslessServiceworker } from './lele-serviceworker.classes.serviceworker.js';
+
+export type {
+  LosslessServiceworker
+}
+
+export const getServiceWorker = async () => {
+  const losslessServiceWorkerInstance = await LosslessServiceworker.createServiceWorker(); // lets setup the service worker
+  logger.log('ok', 'service worker ready!'); // and wait for it to be ready
+  return losslessServiceWorkerInstance;
+};
--- a/ts_web_serviceworker_client/interfaces/index.ts
+++ b/ts_web_serviceworker_client/interfaces/index.ts
@ -0,0 +1,2 @@
+import * as plugins from '../lele-serviceworker.plugins.js';
+
--- a/ts_web_serviceworker_client/lele-serviceworker.classes.actionmanager.ts
+++ b/ts_web_serviceworker_client/lele-serviceworker.classes.actionmanager.ts
@ -0,0 +1,58 @@
+import * as plugins from './lele-serviceworker.plugins.js';
+import * as interfaces from './interfaces/index.js';
+import { logger } from './serviceworker.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.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.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.IRequest_PurgeServiceWorkerCache>('purgeServiceWorkerCache');
+    const response = await tr.fire({});
+    return response;
+  }
+
+  public async getVersionInfo () {
+    const tr = this.deesComms.createTypedRequest<interfaces.IRequest_Serviceworker_Backend_VersionInfo>('serviceworker_versionInfo');
+    const response = await tr.fire({});
+    return response;
+  }
+}
--- a/ts_web_serviceworker_client/lele-serviceworker.classes.globalsw.ts
+++ b/ts_web_serviceworker_client/lele-serviceworker.classes.globalsw.ts
@ -0,0 +1,29 @@
+import * as plugins from './lele-serviceworker.plugins.js';
+import { LosslessServiceworker } from './lele-serviceworker.classes.serviceworker.js';
+
+export class GlobalSW {
+  losslessSw: LosslessServiceworker;
+  constructor(losslessServiceWorkerInstanceArg: LosslessServiceworker) {
+    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/lele-serviceworker.classes.notificationmanager.ts
+++ b/ts_web_serviceworker_client/lele-serviceworker.classes.notificationmanager.ts
@ -0,0 +1,16 @@
+import * as plugins from './lele-serviceworker.plugins.js';
+import * as interfaces from './interfaces/index.js';
+import { logger } from "./serviceworker.logging.js";
+
+export class NotificationManager {
+
+  constructor() {
+    // this.askPermission();
+  }
+
+  public askPermission () {
+    Notification.requestPermission((status) => {
+      console.log('Notification permission status:', status);
+    });
+  }
+}
--- a/ts_web_serviceworker_client/lele-serviceworker.classes.serviceworker.ts
+++ b/ts_web_serviceworker_client/lele-serviceworker.classes.serviceworker.ts
@ -0,0 +1,69 @@
+import * as plugins from './lele-serviceworker.plugins.js';
+import * as interfaces from './interfaces/index.js';
+import { logger } from "./serviceworker.logging.js";
+import { NotificationManager } from './lele-serviceworker.classes.notificationmanager.js';
+import { ActionManager } from './lele-serviceworker.classes.actionmanager.js';
+import { GlobalSW } from './lele-serviceworker.classes.globalsw.js'
+
+export class LosslessServiceworker {
+  // STATIC
+  public static async createServiceWorker(): Promise<LosslessServiceworker> {
+    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('/lsw.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 LosslessServiceworker();
+        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/lele-serviceworker.classes.serviceworkerbackend.ts
+++ b/ts_web_serviceworker_client/lele-serviceworker.classes.serviceworkerbackend.ts
--- a/ts_web_serviceworker_client/lele-serviceworker.plugins.ts
+++ b/ts_web_serviceworker_client/lele-serviceworker.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
+};
--- a/ts_web_serviceworker_client/serviceworker.logging.ts
+++ b/ts_web_serviceworker_client/serviceworker.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/tsconfig.json
+++ b/tsconfig.json
@ -1,9 +1,14 @@
 {
  "compilerOptions": {
    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "nodenext",
-    "esModuleInterop": true
-  }
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
 }
Author	SHA1	Message	Date
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
Philipp Kunz	e8c1a66e15	3.0.22	2024-02-21 01:06:53 +01:00
Philipp Kunz	1e98fd99f4	fix(core): update	2024-02-21 01:06:52 +01:00
Philipp Kunz	da6aa9827c	3.0.21	2024-02-20 17:30:47 +01:00
Philipp Kunz	ca3b8a4580	fix(core): update	2024-02-20 17:30:46 +01:00
Philipp Kunz	a7ddb6b6a8	3.0.20	2024-01-19 20:52:00 +01:00
Philipp Kunz	e1dfe30273	fix(core): update	2024-01-19 20:51:59 +01:00
Philipp Kunz	754fa38fe8	3.0.19	2024-01-09 11:38:52 +01:00
Philipp Kunz	7e59146e73	fix(core): update	2024-01-09 11:38:51 +01:00
Philipp Kunz	3b550eacf7	3.0.18	2024-01-09 11:38:19 +01:00
Philipp Kunz	6342895320	fix(core): update	2024-01-09 11:38:18 +01:00
Philipp Kunz	b6a4095a53	3.0.17	2024-01-09 11:38:06 +01:00
Philipp Kunz	622da78180	fix(core): update	2024-01-09 11:38:06 +01:00
Philipp Kunz	21938e5f20	3.0.16	2024-01-09 10:25:04 +01:00
Philipp Kunz	99427f5835	fix(core): update	2024-01-09 10:25:03 +01:00
Philipp Kunz	552a15bb2f	3.0.15	2024-01-09 10:21:02 +01:00
Philipp Kunz	b0efc48b96	fix(core): update	2024-01-09 10:21:01 +01:00
Philipp Kunz	8c3aad69a0	3.0.14	2024-01-09 10:14:07 +01:00
Philipp Kunz	fb2692b50e	fix(core): update	2024-01-09 10:14:06 +01:00
Philipp Kunz	65c868aefe	3.0.13	2024-01-08 15:34:54 +01:00
Philipp Kunz	11df25f028	fix(core): update	2024-01-08 15:34:53 +01:00
Philipp Kunz	efb4229f58	3.0.12	2024-01-08 14:43:12 +01:00
Philipp Kunz	61dcc6badc	fix(core): update	2024-01-08 14:43:11 +01:00
Philipp Kunz	585da9bc79	3.0.11	2024-01-08 14:35:35 +01:00
Philipp Kunz	60a2efaecb	fix(core): update	2024-01-08 14:35:34 +01:00
Philipp Kunz	2c8f550830	3.0.10	2024-01-07 14:50:14 +01:00
Philipp Kunz	c9688159e5	fix(core): update	2024-01-07 14:50:14 +01:00
Philipp Kunz	a710473d33	3.0.9	2023-11-06 13:56:03 +01:00
Philipp Kunz	61c62672fc	fix(core): update	2023-11-06 13:56:02 +01:00
Philipp Kunz	1a7150e1f8	3.0.8	2023-11-06 11:29:53 +01:00
Philipp Kunz	f35360adba	fix(core): update	2023-11-06 11:29:52 +01:00
Philipp Kunz	9774567dc0	3.0.7	2023-10-23 16:52:32 +02:00
Philipp Kunz	529c5feeb1	fix(core): update	2023-10-23 16:52:31 +02:00
Philipp Kunz	d2cac36a6e	3.0.6	2023-10-20 18:13:11 +02:00
Philipp Kunz	2cdef55f13	fix(core): update	2023-10-20 18:13:10 +02:00
Philipp Kunz	05444b757b	3.0.5	2023-09-21 00:48:05 +02:00
Philipp Kunz	1ef5c0da06	fix(core): update	2023-09-21 00:48:04 +02:00
Philipp Kunz	00b4108803	3.0.4	2023-08-06 18:15:02 +02:00
Philipp Kunz	7e75cccbcb	fix(core): update	2023-08-06 18:15:01 +02:00
Philipp Kunz	f93d10d394	3.0.3	2023-08-06 17:45:31 +02:00
Philipp Kunz	d949a05c79	fix(core): update	2023-08-06 17:45:30 +02:00
Philipp Kunz	d281569bbb	3.0.2	2023-08-06 15:51:35 +02:00
Philipp Kunz	ef06dd138e	fix(core): update	2023-08-06 15:51:34 +02:00
Philipp Kunz	60b610fc4a	3.0.1	2023-08-03 20:50:18 +02:00
Philipp Kunz	b4e9bd5174	fix(core): update	2023-08-03 20:50:18 +02:00
Philipp Kunz	1754524184	3.0.0	2023-08-03 20:45:10 +02:00
Philipp Kunz	618f382ce9	BREAKING CHANGE(core): update	2023-08-03 20:45:09 +02:00
Philipp Kunz	ef9883f100	2.0.65	2023-07-02 11:35:37 +02:00
Philipp Kunz	99db788d11	fix(core): update	2023-07-02 11:35:36 +02:00
Philipp Kunz	f7966e1f58	2.0.64	2023-07-02 02:09:04 +02:00
Philipp Kunz	9828f7bc13	fix(core): update	2023-07-02 02:09:04 +02:00
Philipp Kunz	dab87b274d	2.0.63	2023-07-02 01:53:11 +02:00
Philipp Kunz	85171cb736	fix(core): update	2023-07-02 01:53:10 +02:00
Philipp Kunz	0fd5e0a209	2.0.62	2023-07-02 01:46:53 +02:00
Philipp Kunz	eadab07f17	fix(core): update	2023-07-02 01:46:53 +02:00
Philipp Kunz	378592acc3	2.0.61	2023-07-02 01:38:50 +02:00
Philipp Kunz	f885e49e34	fix(core): update	2023-07-02 01:38:49 +02:00
Philipp Kunz	078730153d	2.0.60	2023-07-02 01:23:41 +02:00
Philipp Kunz	4467ab76aa	fix(core): update	2023-07-02 01:23:41 +02:00
Philipp Kunz	a0bbf31f75	2.0.59	2023-07-01 18:25:27 +02:00
Philipp Kunz	13e9ac7a98	fix(core): update	2023-07-01 18:25:27 +02:00
Philipp Kunz	0ec00a5404	2.0.58	2023-07-01 17:23:50 +02:00
Philipp Kunz	b0f48ba598	fix(core): update	2023-07-01 17:23:49 +02:00
				`@ -0,0 +1,2 @@`
				`import * as plugins from '../lele-serviceworker.plugins.js';`