3.0.28

fix(core): update
update documentation
2024-04-19 01:01:29 +02:00 · 2024-04-19 01:01:29 +02:00 · 2024-04-14 19:00:39 +02:00 · 2024-03-03 10:36:46 +01:00 · 2024-03-03 10:36:45 +01:00 · 2024-03-01 00:14:34 +01:00
37 changed files with 3706 additions and 1727 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.gitea/workflows/default_nottags.yaml
@ -0,0 +1,67 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install pnpm and npmci
+      run: |
+        pnpm install -g pnpm
+        pnpm install -g @shipzone/npmci
+
+    - name: Run npm prepare
+      run: npmci npm prepare
+
+    - name: Audit production dependencies
+      run: |
+        npmci command npm config set registry https://registry.npmjs.org
+        npmci command pnpm audit --audit-level=high --prod
+      continue-on-error: true
+
+    - name: Audit development dependencies
+      run: |
+        npmci command npm config set registry https://registry.npmjs.org
+        npmci command pnpm audit --audit-level=high --dev
+      continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Test stable
+      run: |
+        npmci node install stable
+        npmci npm install
+        npmci npm test
+
+    - name: Test build
+      run: |
+        npmci node install stable
+        npmci npm install
+        npmci npm build
--- a/.gitea/workflows/default_tags.yaml
+++ b/.gitea/workflows/default_tags.yaml
@ -0,0 +1,110 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install pnpm and npmci
+      run: |
+        pnpm install -g pnpm
+        pnpm install -g @shipzone/npmci
+
+    - name: Run npm prepare
+      run: npmci npm prepare
+
+    - name: Audit production dependencies
+      run: |
+        npmci command npm config set registry https://registry.npmjs.org
+        npmci command pnpm audit --audit-level=high --prod
+      continue-on-error: true
+
+    - name: Audit development dependencies
+      run: |
+        npmci command npm config set registry https://registry.npmjs.org
+        npmci command pnpm audit --audit-level=high --dev
+      continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Test stable
+      run: |
+        npmci node install stable
+        npmci npm install
+        npmci npm test
+
+    - name: Test build
+      run: |
+        npmci node install stable
+        npmci npm install
+        npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Release
+      run: |
+        npmci node install stable
+        npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Code quality
+      run: |
+        npmci command npm install -g typescript
+        npmci npm prepare
+        npmci npm install
+
+    - name: Trigger
+      run: npmci trigger
+
+    - name: Build docs and upload artifacts
+      run: |
+        npmci node install stable
+        npmci npm install
+        pnpm install -g @git.zone/tsdoc
+        npmci command tsdoc
+      continue-on-error: true
--- a/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,13 +1,13 @@
 {
-  "name": "@apiglobal/typedserver",
-  "version": "2.0.35",
-  "description": "easy serving of static files",
+  "name": "@api.global/typedserver",
+  "version": "3.0.28",
+  "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
  "main": "dist_ts/index.js",
  "typings": "dist_ts/index.d.ts",
  "type": "module",
  "scripts": {
    "test": "npm run build && tstest test/",
-    "build": "tsbuild --web --allowimplicitany && tsbundle --from ./ts_web/index.ts --to ./dist_ts_web/bundle.js",
+    "build": "tsbuild --web --allowimplicitany --skiplibcheck && tsbundle --from ./ts_web/index.ts --to ./dist_ts_web/bundle.js",
    "buildDocs": "tsdoc"
  },
  "repository": {
@ -15,8 +15,20 @@
    "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,29 +49,44 @@
  ],
  "homepage": "https://github.com/pushrocks/easyserve",
  "dependencies": {
-    "@apiglobal/typedrequest": "^2.0.12",
-    "@apiglobal/typedrequest-interfaces": "^2.0.1",
-    "@apiglobal/typedsocket": "^2.0.22",
-    "@pushrocks/smartchok": "^1.0.23",
-    "@pushrocks/smartdelay": "^2.0.13",
-    "@pushrocks/smartexpress": "^4.0.34",
-    "@pushrocks/smartfile": "^10.0.7",
-    "@pushrocks/smartlog": "^3.0.1",
-    "@pushrocks/smartlog-destination-devtools": "^1.0.10",
-    "@pushrocks/smartopen": "^2.0.0",
-    "@pushrocks/smartpath": "^5.0.5",
-    "@pushrocks/smartpromise": "^3.1.7",
-    "@pushrocks/smartrx": "^3.0.0",
-    "@pushrocks/webstore": "^2.0.5",
-    "lit": "^2.7.0"
+    "@api.global/typedrequest": "^3.0.21",
+    "@api.global/typedrequest-interfaces": "^3.0.18",
+    "@api.global/typedsocket": "^3.0.1",
+    "@push.rocks/lik": "^6.0.15",
+    "@push.rocks/smartchok": "^1.0.33",
+    "@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.14",
+    "@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.34",
+    "@push.rocks/smarttime": "^4.0.6",
+    "@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.19.2",
+    "express-force-ssl": "^0.3.2",
+    "lit": "^3.1.3"
  },
  "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.63",
-    "@gitzone/tsbundle": "^2.0.6",
-    "@gitzone/tsrun": "^1.2.39",
-    "@gitzone/tstest": "^1.0.72",
-    "@pushrocks/tapbundle": "^5.0.4",
-    "@types/node": "^18.15.11"
+    "@git.zone/tsbuild": "^2.1.72",
+    "@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.7"
  },
  "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 @@
-# @apiglobal/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';

@ -10,6 +10,7 @@ tap.test('should create a valid instance of TypedServer', async () => {
    port: 3000,
    serveDir: smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
    watch: true,
+    cors: true,
  });
  expect(testTypedServer).toBeInstanceOf(TypedServer);
 });
--- a/test/test.server.ts
+++ b/test/test.server.ts
@ -0,0 +1,135 @@
+// tslint:disable-next-line:no-implicit-dependencies
+import { expect, tap } from '@push.rocks/tapbundle';
+
+// helper dependencies
+// tslint:disable-next-line:no-implicit-dependencies
+
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartrequest from '@push.rocks/smartrequest';
+
+import * as typedserver from '../ts/index.js';
+
+let testServer: typedserver.servertools.Server;
+let testRoute: typedserver.servertools.Route;
+let testRoute2: typedserver.servertools.Route;
+let testHandler: typedserver.servertools.Handler;
+
+// =================
+// Test class Server
+// =================
+
+tap.test('should create a valid Server', async () => {
+  testServer = new typedserver.servertools.Server({
+    cors: true,
+    domain: 'testing.git.zone',
+    forceSsl: false,
+    appVersion: 'v3.2.1',
+    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,
+    robots: true,
+  });
+  expect(testServer).toBeInstanceOf(typedserver.servertools.Server);
+});
+
+// ================
+// Test class Route
+// ================
+
+tap.test('should create a valid Route', async () => {
+  testRoute = testServer.addRoute('/someroute');
+  testRoute2 = testServer.addRoute('/someroute/*');
+  expect(testRoute).toBeInstanceOf(typedserver.servertools.Route);
+});
+
+// ==================
+// Test class Handler
+// ==================
+
+tap.test('should produce a valid handler', async () => {
+  testHandler = new typedserver.servertools.Handler('POST', (request, response) => {
+    console.log('request body is:');
+    console.log(request.body);
+    response.send('hi');
+  });
+  expect(testHandler).toBeInstanceOf(typedserver.servertools.Handler);
+});
+
+tap.test('should add handler to route', async () => {
+  testRoute.addHandler(testHandler);
+});
+
+tap.test('should create a valid StaticHandler', async () => {
+  testRoute2.addHandler(
+    new typedserver.servertools.HandlerStatic(
+      smartpath.get.dirnameFromImportMetaUrl(import.meta.url)
+    )
+  );
+});
+
+tap.test('should add typedrequest and typedsocket', async () => {
+  const typedrequest = await import('@api.global/typedrequest');
+
+  const typedrouter = new typedrequest.TypedRouter();
+  testServer.addTypedRequest(typedrouter);
+  testServer.addTypedSocket(typedrouter);
+});
+
+// =====================
+// start the server and test the configuration
+// =====================
+
+tap.test('should start the server allright', async () => {
+  await testServer.start(3000);
+});
+
+// see if a demo request holds up
+tap.test('should issue a request', async (tools) => {
+  const response = await smartrequest.postJson('http://127.0.0.1:3000/someroute', {
+    headers: {
+      'X-Forwarded-Proto': 'https',
+    },
+    requestBody: {
+      someprop: 'hi',
+    },
+  });
+  console.log(response.body);
+});
+
+tap.test('should get a file from disk', async () => {
+  const response = await fetch('http://127.0.0.1:3000/someroute/testresponse.js');
+  console.log(response.status);
+  console.log(response.headers);
+});
+
+tap.test('should answer a preflight request', async () => {
+  const response = await fetch('http://127.0.0.1:3000/some/randompath/', {
+    method: 'OPTIONS',
+  });
+  console.log(response.headers);
+});
+
+tap.test('should exposer a sitemap', async () => {
+  const response = await fetch('http://127.0.0.1:3000/sitemap');
+  console.log(await response.text());
+});
+
+// ========
+// clean up
+// ========
+
+tap.test('should stop the server', async () => {
+  await testServer.stop();
+});
+
+tap.start();
--- 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.35',
-  description: 'easy serving of static files'
+  name: '@api.global/typedserver',
+  version: '3.0.28',
+  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 +1,10 @@
+import * as plugins from './plugins.js';
+
+import * as servertools from './servertools/index.js';
+
+export { servertools };
+
 export * from './typedserver.classes.typedserver.js';
+// Type helpers
+export type Request = plugins.express.Request;
+export type Response = plugins.express.Response;
--- a/ts/interfaces/index.ts
+++ b/ts/interfaces/index.ts
@ -1,12 +1,3 @@
-import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
-
-export interface IReq_PushLatestServerChangeTime extends typedrequestInterfaces.implementsTR<
-  typedrequestInterfaces.ITypedRequest,
-  IReq_PushLatestServerChangeTime
-> {
-  method: 'pushLatestServerChangeTime',
-  request: {
-    time: number;
-  };
-  response: {}
-}
+export * from './requestmodifier.js';
+export * from './responsemodifier.js';
+export * from './typedrequests.js';
--- a/ts/interfaces/requestmodifier.ts
+++ b/ts/interfaces/requestmodifier.ts
@ -0,0 +1,11 @@
+export type TRequestModifier = <T>(responseArg: {
+  headers: { [header: string]: string | string[] | undefined };
+  path: string;
+  body: string;
+  travelData?: T;
+}) => Promise<{
+  headers: { [header: string]: string | string[] | undefined };
+  path: string;
+  body: string;
+  travelData?: T;
+}>;
--- a/ts/interfaces/responsemodifier.ts
+++ b/ts/interfaces/responsemodifier.ts
@ -0,0 +1,11 @@
+export type TResponseModifier = <T>(responseArg: {
+  headers: { [header: string]: number | string | string[] | undefined };
+  path: string;
+  responseContent: Buffer;
+  travelData?: T;
+}) => Promise<{
+  headers: { [header: string]: number | string | string[] | undefined };
+  path: string;
+  responseContent: Buffer;
+  travelData?: T;
+}>;
--- a/ts/interfaces/typedrequests.ts
+++ b/ts/interfaces/typedrequests.ts
@ -0,0 +1,26 @@
+// 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<
+    typedrequestInterfaces.ITypedRequest,
+    IReq_PushLatestServerChangeTime
+  > {
+  method: 'pushLatestServerChangeTime';
+  request: {
+    time: number;
+  };
+  response: {};
+}
+
+export interface IReq_GetLatestServerChangeTime
+  extends typedrequestInterfaces.implementsTR<
+    typedrequestInterfaces.ITypedRequest,
+    IReq_GetLatestServerChangeTime
+  > {
+  method: 'getLatestServerChangeTime';
+  request: {};
+  response: {
+    time: number;
+  };
+}
--- 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
@ -0,0 +1,35 @@
+import { Handler } from './classes.handler.js';
+import { Server } from './classes.server.js';
+import * as plugins from '../plugins.js';
+
+export class Feed {
+  public smartexpressRef: Server;
+  public smartfeedInstance = new plugins.smartfeed.Smartfeed();
+
+  public feedHandler = new Handler('GET', async (req, res) => {
+    if (!this.smartexpressRef.options.feedMetadata) {
+      res.status(500);
+      res.write('feed metadata is missing');
+      res.end();
+      return;
+    }
+    if (!this.smartexpressRef.options.articleGetterFunction) {
+      res.status(500);
+      res.write('no article getter function defined.');
+      res.end();
+      return;
+    }
+    const xmlString = await this.smartfeedInstance.createFeedFromArticleArray(
+      this.smartexpressRef.options.feedMetadata,
+      await this.smartexpressRef.options.articleGetterFunction()
+    );
+    res.type('.xml');
+    res.write(xmlString);
+    res.end();
+  });
+
+  constructor(smartexpressRefArg: Server) {
+    this.smartexpressRef = smartexpressRefArg;
+    this.smartexpressRef.addRouteBefore('/feed', this.feedHandler);
+  }
+}
--- a/ts/servertools/classes.handler.ts
+++ b/ts/servertools/classes.handler.ts
@ -0,0 +1,17 @@
+import * as plugins from '../plugins.js';
+import { type Request, type Response } from 'express';
+
+export interface IHandlerFunction {
+  (requestArg: Request, responseArg: Response): void;
+}
+
+export type THttpMethods = 'ALL' | 'GET' | 'POST' | 'PUT' | 'DELETE';
+
+export class Handler {
+  httpMethod: THttpMethods;
+  handlerFunction: IHandlerFunction;
+  constructor(httpMethodArg: THttpMethods, handlerArg: IHandlerFunction) {
+    this.httpMethod = httpMethodArg;
+    this.handlerFunction = handlerArg;
+  }
+}
--- a/ts/servertools/classes.handlerproxy.ts
+++ b/ts/servertools/classes.handlerproxy.ts
@ -0,0 +1,77 @@
+import * as plugins from '../plugins.js';
+import { Handler } from './classes.handler.js';
+
+import * as interfaces from '../interfaces/index.js';
+
+export class HandlerProxy extends Handler {
+  /**
+   * The constuctor of HandlerProxy
+   * @param remoteMountPointArg
+   */
+  constructor(
+    remoteMountPointArg: string,
+    optionsArg?: {
+      responseModifier?: interfaces.TResponseModifier;
+      headers?: { [key: string]: string };
+    }
+  ) {
+    super('ALL', async (req, res) => {
+      const relativeRequestPath = req.path.slice(req.route.path.length - 1);
+      const proxyRequestUrl = remoteMountPointArg + relativeRequestPath;
+      console.log(`proxy ${req.path} to ${proxyRequestUrl}`);
+      let proxiedResponse: plugins.smartrequest.IExtendedIncomingMessage;
+      try {
+        proxiedResponse = await plugins.smartrequest.request(proxyRequestUrl, {
+          method: req.method,
+          autoJsonParse: false,
+        });
+      } catch {
+        res.end('failed to fullfill request');
+        return;
+      }
+      for (const header of Object.keys(proxiedResponse.headers)) {
+        res.set(header, proxiedResponse.headers[header] as string);
+      }
+
+      // set additional headers
+      if (optionsArg && optionsArg.headers) {
+        for (const key of Object.keys(optionsArg.headers)) {
+          res.set(key, optionsArg.headers[key]);
+        }
+      }
+
+      let responseToSend: Buffer = proxiedResponse.body;
+      if (typeof responseToSend !== 'string') {
+        console.log(proxyRequestUrl);
+        console.log(responseToSend);
+        throw new Error(`Proxied response is not a string, but ${typeof responseToSend}`);
+      }
+
+      if (optionsArg && optionsArg.responseModifier) {
+        const modifiedResponse = await optionsArg.responseModifier({
+          headers: res.getHeaders(),
+          path: req.path,
+          responseContent: responseToSend,
+        });
+
+        // headers
+        for (const key of Object.keys(res.getHeaders())) {
+          if (!modifiedResponse.headers[key]) {
+            res.removeHeader(key);
+          }
+        }
+
+        for (const key of Object.keys(modifiedResponse.headers)) {
+          res.setHeader(key, modifiedResponse.headers[key]);
+        }
+
+        // responseContent
+        responseToSend = modifiedResponse.responseContent;
+      }
+
+      res.status(200);
+      res.write(responseToSend);
+      res.end();
+    });
+  }
+}
--- a/ts/servertools/classes.handlerstatic.ts
+++ b/ts/servertools/classes.handlerstatic.ts
@ -0,0 +1,142 @@
+import * as plugins from '../plugins.js';
+import * as interfaces from '../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?: {
+      requestModifier?: interfaces.TRequestModifier;
+      responseModifier?: interfaces.TResponseModifier;
+      headers?: { [key: string]: string };
+      serveIndexHtmlDefault?: boolean;
+      enableCompression?: boolean;
+      preferredCompressionMethod?: TCompressionMethod;
+    }
+  ) {
+    super('GET', async (req, res) => {
+      let requestPath = req.path;
+      let requestHeaders = req.headers;
+      let requestBody = req.body;
+      let travelData: unknown;
+      if (optionsArg && optionsArg.requestModifier) {
+        const modifiedRequest = await optionsArg.requestModifier({
+          headers: requestHeaders,
+          path: requestPath,
+          body: requestBody,
+        });
+
+        requestHeaders = modifiedRequest.headers;
+        requestPath = modifiedRequest.path;
+        requestBody = modifiedRequest.body;
+        travelData = modifiedRequest.travelData;
+      }
+
+      // lets compute some paths
+      let filePath: string = requestPath.slice(req.route.path.length - 1); // lets slice of the root
+      if (requestPath === '') {
+        console.log('replaced root with index.html');
+        filePath = 'index.html';
+      }
+      console.log(filePath);
+      const joinedPath = plugins.path.join(pathArg, filePath);
+      const defaultPath = plugins.path.join(pathArg, 'index.html');
+      let parsedPath = plugins.path.parse(joinedPath);
+      let usedPath: string;
+
+      // important security checks
+      if (
+        requestPath.includes('..') || // don't allow going up the filePath
+        requestPath.includes('~') || // don't allow referencing of home directory
+        !joinedPath.startsWith(pathArg) // make sure the joined path is within the directory
+      ) {
+        res.writeHead(500);
+        res.end();
+        return;
+      }
+
+      // set additional headers
+      if (optionsArg && optionsArg.headers) {
+        for (const key of Object.keys(optionsArg.headers)) {
+          res.set(key, optionsArg.headers[key]);
+        }
+      }
+
+      // lets actually care about serving, if security checks pass
+      let fileBuffer: Buffer;
+      try {
+        fileBuffer = plugins.smartfile.fs.toBufferSync(joinedPath);
+        usedPath = joinedPath;
+      } catch (err) {
+        // try serving index.html instead
+        console.log(`could not resolve ${joinedPath}`);
+        if (optionsArg && optionsArg.serveIndexHtmlDefault) {
+          console.log(`serving default path ${defaultPath} instead of ${joinedPath}`);
+          try {
+            parsedPath = plugins.path.parse(defaultPath);
+            fileBuffer = plugins.smartfile.fs.toBufferSync(defaultPath);
+            usedPath = defaultPath;
+          } catch (err) {
+            res.writeHead(500);
+            res.end('File not found!');
+            return;
+          }
+        } else {
+          res.writeHead(500);
+          res.end('File not found!');
+          return;
+        }
+      }
+
+      res.type(parsedPath.ext);
+
+      const headers = res.getHeaders();
+
+      // lets modify the response at last
+      if (optionsArg && optionsArg.responseModifier) {
+        const modifiedResponse = await optionsArg.responseModifier({
+          headers: res.getHeaders(),
+          path: usedPath,
+          responseContent: fileBuffer,
+          travelData,
+        });
+
+        // headers
+        for (const key of Object.keys(res.getHeaders())) {
+          if (!modifiedResponse.headers[key]) {
+            res.removeHeader(key);
+          }
+        }
+
+        for (const key of Object.keys(modifiedResponse.headers)) {
+          res.setHeader(key, modifiedResponse.headers[key]);
+        }
+
+        // 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);
+      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
@ -0,0 +1,19 @@
+import * as plugins from '../plugins.js';
+import { Handler } from './classes.handler.js';
+
+import * as interfaces from '../interfaces/index.js';
+
+export class HandlerTypedRouter extends Handler {
+  /**
+   * The constuctor of HandlerProxy
+   * @param remoteMountPointArg
+   */
+  constructor(typedrouter: plugins.typedrequest.TypedRouter) {
+    super('POST', async (req, res) => {
+      const response = await typedrouter.routeAndAddResponse(req.body);
+      res.type('json');
+      res.write(plugins.smartjson.stringify(response));
+      res.end();
+    });
+  }
+}
--- a/ts/servertools/classes.route.ts
+++ b/ts/servertools/classes.route.ts
@ -0,0 +1,31 @@
+import * as plugins from '../plugins.js';
+import { Handler } from './classes.handler.js';
+import { Server } from './classes.server.js';
+
+import { type IRoute as IExpressRoute } from 'express';
+
+export class Route {
+  public routeString: string;
+  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;
+  }
+
+  /**
+   * add a handler to do something with requests
+   * @param handlerArg
+   */
+  public addHandler(handlerArg: Handler) {
+    this.handlerObjectMap.add(handlerArg);
+  }
+
+  /**
+   * add a express middleware
+   * @param middlewareArg
+   */
+  public addExpressMiddleWare(middlewareArg: plugins.express.Application) {
+    this.expressMiddlewareObjectMap.add(middlewareArg);
+  }
+}
--- a/ts/servertools/classes.server.ts
+++ b/ts/servertools/classes.server.ts
@ -0,0 +1,333 @@
+import * as plugins from '../plugins.js';
+
+import { Route } from './classes.route.js';
+import { Handler } from './classes.handler.js';
+import { HandlerTypedRouter } from './classes.handlertypedrouter.js';
+
+// export types
+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';
+export type TServerStatus = 'initiated' | 'running' | 'stopped';
+
+/**
+ * can be used to spawn a server to answer http/https calls
+ * for constructor options see [[IServerOptions]]
+ */
+export class Server {
+  public httpServer: plugins.http.Server | plugins.https.Server;
+  public expressAppInstance: plugins.express.Application;
+  public routeObjectMap = new Array<Route>();
+  public options: IServerOptions;
+  public serverStatus: TServerStatus = 'initiated';
+
+  public feed: Feed;
+  public sitemap: Sitemap;
+
+  public executeAfterStartFunctions: (() => Promise<void>)[] = [];
+
+  // do stuff when server is ready
+  private startedDeferred = plugins.smartpromise.defer();
+  // tslint:disable-next-line:member-ordering
+  public startedPromise = this.startedDeferred.promise;
+
+  private socketMap = new plugins.lik.ObjectMap<plugins.net.Socket>();
+
+  constructor(optionsArg: IServerOptions) {
+    this.options = {
+      ...optionsArg,
+    };
+  }
+
+  /**
+   * allows updating of server options
+   * @param optionsArg
+   */
+  public updateServerOptions(optionsArg: IServerOptions) {
+    Object.assign(this.options, optionsArg);
+  }
+
+  public addTypedRequest(typedrouter: plugins.typedrequest.TypedRouter) {
+    this.addRoute('/typedrequest', new HandlerTypedRouter(typedrouter));
+  }
+
+  public addTypedSocket(typedrouter: plugins.typedrequest.TypedRouter): void {
+    this.executeAfterStartFunctions.push(async () => {
+      plugins.typedsocket.TypedSocket.createServer(typedrouter, this);
+    });
+  }
+
+  public addRoute(routeStringArg: string, handlerArg?: Handler) {
+    const route = new Route(this, routeStringArg);
+    if (handlerArg) {
+      route.addHandler(handlerArg);
+    }
+    this.routeObjectMap.push(route);
+    return route;
+  }
+
+  public addRouteBefore(routeStringArg: string, handlerArg?: Handler) {
+    const route = new Route(this, routeStringArg);
+    if (handlerArg) {
+      route.addHandler(handlerArg);
+    }
+    this.routeObjectMap.unshift(route);
+    return route;
+  }
+
+  public async start(portArg: number | string = this.options.port, doListen = true) {
+    const done = plugins.smartpromise.defer();
+
+    if (typeof portArg === 'string') {
+      portArg = parseInt(portArg);
+    }
+
+    this.expressAppInstance = plugins.express();
+    if (!this.httpServer && (!this.options.privateKey || !this.options.publicKey)) {
+      console.log('Got no SSL certificates. Please ensure encryption using e.g. a reverse proxy');
+      this.httpServer = plugins.http.createServer(this.expressAppInstance);
+    } else if (!this.httpServer) {
+      console.log('Got SSL certificate. Using it for the http server');
+      this.httpServer = plugins.https.createServer(
+        {
+          key: this.options.privateKey,
+          cert: this.options.publicKey,
+        },
+        this.expressAppInstance
+      );
+    } else {
+      console.log('Using externally supplied http server');
+    }
+    this.httpServer.keepAliveTimeout = 600 * 1000;
+    this.httpServer.headersTimeout = 20 * 1000;
+
+    // general request handlling
+    this.expressAppInstance.use((req, res, next) => {
+      next();
+    });
+
+    // forceSsl
+    if (this.options.forceSsl) {
+      this.expressAppInstance.set('forceSSLOptions', {
+        enable301Redirects: true,
+        trustXFPHeader: true,
+        sslRequiredMessage: 'SSL Required.',
+      });
+      this.expressAppInstance.use(plugins.expressForceSsl);
+    }
+
+    // cors
+    if (this.options.cors) {
+      const cors = plugins.cors({
+        allowedHeaders: '*',
+        methods: '*',
+        origin: '*',
+      });
+
+      this.expressAppInstance.use(cors);
+      this.expressAppInstance.options('/*', cors);
+    }
+
+    this.expressAppInstance.use((req, res, next) => {
+      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+      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');
+      res.setHeader('Expires', new Date(Date.now()).toUTCString());
+      next();
+    });
+
+    // body parsing
+    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
+    if (this.options.robots && this.options.domain) {
+      await setupRobots(this, this.options.domain);
+    }
+
+    // manifest.json
+    if (this.options.manifest) {
+      await setupManifest(this.expressAppInstance, this.options.manifest);
+    }
+
+    // sitemaps
+    if (this.options.sitemap) {
+      this.sitemap = new Sitemap(this);
+    }
+
+    if (this.options.feed) {
+      // feed
+      this.feed = new Feed(this);
+    }
+
+    // appVersion
+    if (this.options.appVersion) {
+      this.expressAppInstance.use((req, res, next) => {
+        res.set('appversion', this.options.appVersion);
+        next();
+      });
+      this.addRoute(
+        '/appversion',
+        new Handler('GET', async (req, res) => {
+          res.write(this.options.appVersion);
+          res.end();
+        })
+      );
+    }
+
+    // set up routes in for express
+    await this.routeObjectMap.forEach(async (routeArg) => {
+      console.log(
+        `"${routeArg.routeString}" maps to ${routeArg.handlerObjectMap.getArray().length} handlers`
+      );
+      const expressRoute = this.expressAppInstance.route(routeArg.routeString);
+      routeArg.handlerObjectMap.forEach(async (handler) => {
+        console.log(` -> ${handler.httpMethod}`);
+        switch (handler.httpMethod) {
+          case 'GET':
+            expressRoute.get(handler.handlerFunction);
+            return;
+          case 'POST':
+            expressRoute.post(handler.handlerFunction);
+            return;
+          case 'PUT':
+            expressRoute.put(handler.handlerFunction);
+            return;
+          case 'ALL':
+            expressRoute.all(handler.handlerFunction);
+            return;
+          case 'DELETE':
+            expressRoute.delete(handler.handlerFunction);
+            return;
+          default:
+            return;
+        }
+      });
+    });
+
+    if (this.options.defaultAnswer) {
+      this.expressAppInstance.get('/', async (request, response) => {
+        response.send(await this.options.defaultAnswer());
+      });
+    }
+
+    this.httpServer.on('connection', (connection: plugins.net.Socket) => {
+      this.socketMap.add(connection);
+      console.log(`added connection. now ${this.socketMap.getArray().length} sockets connected.`);
+      
+      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.`);
+          await plugins.smartdelay.delayFor(0);
+          if (connection.destroyed === false) {
+            connection.destroy();
+          }
+        }
+      };
+    });
+
+    // finally listen on a port
+    if (doListen) {
+      this.httpServer.listen(portArg, '0.0.0.0', () => {
+        console.log(`now listening on ${portArg}!`);
+        this.startedDeferred.resolve();
+        this.serverStatus = 'running';
+        done.resolve();
+      });
+    } else {
+      console.log(
+        'The server does not listen on a network stack and instead expects to get handed requests by other mechanics'
+      );
+    }
+    await done.promise;
+    for (const executeAfterStartFunction of this.executeAfterStartFunctions) {
+      await executeAfterStartFunction();
+    }
+  }
+
+  public getHttpServer() {
+    return this.httpServer;
+  }
+
+  public getExpressAppInstance() {
+    return this.expressAppInstance;
+  }
+
+  public async stop() {
+    const done = plugins.smartpromise.defer();
+    if (this.httpServer) {
+      this.httpServer.close(async () => {
+        this.serverStatus = 'stopped';
+        done.resolve();
+      });
+      await this.socketMap.forEach(async (socket) => {
+        socket.destroy();
+      });
+    } else {
+      throw new Error('There is no Server to be stopped. Have you started it?');
+    }
+    return await done.promise;
+  }
+
+  /**
+   * allows handling requests and responses that come from other
+   * @param req
+   * @param res
+   */
+  public async handleReqRes(req: plugins.express.Request, res: plugins.express.Response) {
+    this.expressAppInstance(req, res);
+  }
+}
--- a/ts/servertools/classes.sitemap.ts
+++ b/ts/servertools/classes.sitemap.ts
@ -0,0 +1,68 @@
+import { Server } from './classes.server.js';
+import { Handler } from './classes.handler.js';
+import * as plugins from '../plugins.js';
+import { type IUrlInfo } from '@push.rocks/smartsitemap';
+
+export class Sitemap {
+  public smartexpressRef: Server;
+  public smartSitemap = new plugins.smartsitemap.SmartSitemap();
+  public urls: plugins.smartsitemap.IUrlInfo[] = [];
+
+  /**
+   * handles the normal sitemap request
+   */
+  public sitemapHandler = new Handler('GET', async (req, res) => {
+    const sitemapXmlString = await this.smartSitemap.createSitemapFromUrlInfoArray(this.urls);
+    res.type('.xml');
+    res.write(sitemapXmlString);
+    res.end();
+  });
+
+  /**
+   * handles the sitemap-news request
+   */
+  public sitemapNewsHandler = new Handler('GET', async (req, res) => {
+    if (!this.smartexpressRef.options.articleGetterFunction) {
+      res.status(500);
+      res.write('no article getter function defined.');
+      res.end();
+      return;
+    }
+    const sitemapNewsXml = await this.smartSitemap.createSitemapNewsFromArticleArray(
+      await this.smartexpressRef.options.articleGetterFunction()
+    );
+    res.type('.xml');
+    res.write(sitemapNewsXml);
+    res.end();
+  });
+
+  constructor(smartexpressRefArg: Server) {
+    this.smartexpressRef = smartexpressRefArg;
+    this.smartexpressRef.addRouteBefore('/sitemap', this.sitemapHandler);
+    this.smartexpressRef.addRouteBefore('/sitemap-news', this.sitemapNewsHandler);
+
+    // lets set the default url
+    if (this.smartexpressRef.options.domain) {
+      this.urls.push({
+        url: `https://${this.smartexpressRef.options.domain}/`,
+        timestamp: Date.now(),
+        frequency: 'daily',
+      });
+    }
+  }
+
+  /**
+   * replaces the current urlsArray
+   * @param urlsArg
+   */
+  public replaceUrls(urlsArg: IUrlInfo[]) {
+    this.urls = urlsArg;
+  }
+
+  /**
+   * adds urls to the current set of urls
+   */
+  public addUrls(urlsArg: IUrlInfo[]) {
+    this.urls = this.urls.concat(this.urls, urlsArg);
+  }
+}
--- a/ts/servertools/index.ts
+++ b/ts/servertools/index.ts
@ -0,0 +1,6 @@
+export * from './classes.server.js';
+export * from './classes.route.js';
+export * from './classes.handler.js';
+export * from './classes.handlerstatic.js';
+export * from './classes.handlerproxy.js';
+export * from './classes.handlertypedrouter.js';
--- a/ts/servertools/tools.manifest.ts
+++ b/ts/servertools/tools.manifest.ts
@ -0,0 +1,14 @@
+import * as plugins from '../plugins.js';
+
+export const setupManifest = async (
+  expressInstanceArg: plugins.express.Application,
+  manifestArg: plugins.smartmanifest.ISmartManifestConstructorOptions
+) => {
+  const smartmanifestInstance = new plugins.smartmanifest.SmartManifest(manifestArg);
+  expressInstanceArg.get('/manifest.json', async (req, res) => {
+    res.status(200);
+    res.type('json');
+    res.write(smartmanifestInstance.jsonString());
+    res.end();
+  });
+};
--- a/ts/servertools/tools.robots.ts
+++ b/ts/servertools/tools.robots.ts
@ -0,0 +1,33 @@
+import * as plugins from '../plugins.js';
+import { Server } from './classes.server.js';
+import { Handler } from './classes.handler.js';
+
+export const setupRobots = async (smartexpressRefArg: Server, domainArg: string) => {
+  smartexpressRefArg.addRouteBefore(
+    '/robots.txt',
+    new Handler('GET', async (req, res) => {
+      res.type('text/plain');
+      res.send(`
+User-agent: Googlebot-News
+Disallow: /account
+Disallow: /login
+
+User-agent: *
+Disallow: /account
+Disallow: /login
+
+${
+  smartexpressRefArg.options.blockWaybackMachine
+    ? `
+User-Agent: ia_archiver
+Disallow: /
+`
+    : ``
+}
+
+Sitemap: https://${domainArg}/sitemap
+Sitemap: https://${domainArg}/sitemap-news
+`);
+    })
+  );
+};
--- a/ts/servertools/tools.sslredirect.ts
+++ b/ts/servertools/tools.sslredirect.ts
@ -0,0 +1,22 @@
+import * as plugins from '../plugins.js';
+import { Server } from './classes.server.js';
+import { Handler } from './classes.handler.js';
+
+export const redirectFrom80To443 = async () => {
+  const smartexpressInstance = new Server({
+    cors: true,
+    forceSsl: true,
+    port: 80,
+  });
+
+  smartexpressInstance.addRoute(
+    '*',
+    new Handler('ALL', async (req, res) => {
+      res.redirect('https://' + req.headers.host + req.url);
+    })
+  );
+
+  await smartexpressInstance.start();
+
+  return smartexpressInstance;
+};
--- a/ts/typedserver.classes.typedserver.ts
+++ b/ts/typedserver.classes.typedserver.ts
@ -1,12 +1,69 @@
-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 servertools from './servertools/index.js';
+import { type TCompressionMethod } from './servertools/classes.compressor.js';

-export interface IEasyServerConstructorOptions {
-  serveDir: string;
-  injectReload: boolean;
-  port?: number;
+export interface IServerOptions {
+  /**
+   * serve a particular directory
+   */
+  serveDir?: string;
+
+  /**
+   * inject a reload script that takes care of live reloading
+   */
+  injectReload?: boolean;
+
+  /**
+   * enable compression
+   */
+  enableCompression?: boolean;
+
+  /**
+   * choose a preferred compression method
+   */
+  preferredCompressionMethod?: TCompressionMethod;
+
+  /**
+   * watch the serve directory?
+   */
  watch?: boolean;
+
+  cors: boolean;
+
+  /**
+   * a default answer given in case there is no other handler.
+   * @returns
+   */
+  defaultAnswer?: () => Promise<string>;
+
+  /**
+   * will try to reroute traffic to an ssl connection using headers
+   */
+  forceSsl?: boolean;
+  /**
+   * allows serving manifests
+   */
+  manifest?: plugins.smartmanifest.ISmartManifestConstructorOptions;
+  /**
+   * the port to listen on
+   * can be overwritten when actually starting the server
+   */
+  port?: number | string;
+  publicKey?: string;
+  privateKey?: string;
+  sitemap?: boolean;
+  feed?: boolean;
+  robots?: boolean;
+  domain?: string;
+  /**
+   * convey information about the app being served
+   */
+  appVersion?: string;
+  feedMetadata?: plugins.smartfeed.IFeedOptions;
+  articleGetterFunction?: () => Promise<plugins.tsclass.content.IArticle[]>;
+  blockWaybackMachine?: boolean;
 }

 export class TypedServer {
@ -14,8 +71,8 @@ export class TypedServer {
  // nothing here yet

  // instance
-  public options: IEasyServerConstructorOptions;
-  public smartexpressInstance: plugins.smartexpress.Server;
+  public options: IServerOptions;
+  public server: servertools.Server;
  public smartchokInstance: plugins.smartchok.Smartchok;
  public serveDirHashSubject = new plugins.smartrx.rxjs.ReplaySubject<string>(1);
  public serveHash: string = '000000';
@ -24,34 +81,24 @@ export class TypedServer {

  public lastReload: number = Date.now();
  public ended = false;
-  constructor(optionsArg: IEasyServerConstructorOptions) {
-    const standardOptions: IEasyServerConstructorOptions = {
-      injectReload: true,
+  constructor(optionsArg: IServerOptions) {
+    const standardOptions: IServerOptions = {
      port: 3000,
-      serveDir: process.cwd(),
-      watch: true,
+      injectReload: false,
+      serveDir: null,
+      watch: false,
+      cors: true,
    };
    this.options = {
      ...standardOptions,
      ...optionsArg,
    };
-  }
-
-  /**
-   * inits and starts the server
-   */
-  public async start() {
-    // set the smartexpress instance
-    this.smartexpressInstance = new plugins.smartexpress.Server({
-      port: this.options.port,
-      forceSsl: false,
-      cors: true,
-    });

+    this.server = new servertools.Server(this.options);
    // add routes to the smartexpress instance
-    this.smartexpressInstance.addRoute(
+    this.server.addRoute(
      '/typedserver/:request',
-      new plugins.smartexpress.Handler('ALL', async (req, res) => {
+      new servertools.Handler('ALL', async (req, res) => {
        switch (req.params.request) {
          case 'devtools':
            res.setHeader('Content-Type', 'text/javascript');
@ -73,67 +120,91 @@ export class TypedServer {
        }
      })
    );
+    this.server.addRoute(
+      '/typedrequest',
+      new servertools.HandlerTypedRouter(this.typedrouter)
+    )
+  }

-    this.smartexpressInstance.addRoute(
-      '/*',
-      new plugins.smartexpress.HandlerStatic(this.options.serveDir, {
-        responseModifier: async (responseArg) => {
-          let fileString = responseArg.responseContent;
-          if (plugins.path.parse(responseArg.path).ext === '.html') {
-            const fileStringArray = fileString.split('<head>');
-            if (this.options.injectReload && fileStringArray.length === 2) {
-              fileStringArray[0] = `${fileStringArray[0]}<head>
-                <!-- injected by @apiglobal/typedserver start -->
-                <script async defer type="module" src="/typedserver/devtools"></script>
-                <script>
-                  globalThis.typedserver = {
-                    lastReload: '${this.lastReload}',
-                    versionInfo: ${JSON.stringify({}, null, 2)},
-                  }
-                </script>
-                <!-- injected by @apiglobal/typedserver stop -->
-              `;
-              fileString = fileStringArray.join('');
-              console.log('injected typedserver script.');
-            } else if (this.options.injectReload) {
-              console.log('Could not insert typedserver script');
+  /**
+   * inits and starts the server
+   */
+  public async start() {
+    if (this.options.serveDir) {
+      this.server.addRoute(
+        '/*',
+        new servertools.HandlerStatic(this.options.serveDir, {
+          responseModifier: async (responseArg) => {
+            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) {
+                fileStringArray[0] = `${fileStringArray[0]}<head>
+                  <!-- injected by @apiglobal/typedserver start -->
+                  <script async defer type="module" src="/typedserver/devtools"></script>
+                  <script>
+                    globalThis.typedserver = {
+                      lastReload: ${this.lastReload},
+                      versionInfo: ${JSON.stringify({}, null, 2)},
+                    }
+                  </script>
+                  <!-- injected by @apiglobal/typedserver stop -->
+                `;
+                fileString = fileStringArray.join('');
+                console.log('injected typedserver script.');
+              } else if (this.options.injectReload) {
+                console.log('Could not insert typedserver script');
+              }
            }
-          }
-          const headers = responseArg.headers;
-          headers.appHash = this.serveHash;
-          headers['Cache-Control'] = 'no-cache, no-store, must-revalidate';
-          headers['Pragma'] = 'no-cache';
-          headers['Expires'] = '0';
-          return {
-            headers,
-            path: responseArg.path,
-            responseContent: fileString,
-          };
-        },
-        serveIndexHtmlDefault: true,
-      })
-    );
-
-    this.smartchokInstance = new plugins.smartchok.Smartchok([this.options.serveDir], {});
-    if (this.options.watch) {
+            const headers = responseArg.headers;
+            headers.appHash = this.serveHash;
+            headers['Cache-Control'] = 'no-cache, no-store, must-revalidate';
+            headers['Pragma'] = 'no-cache';
+            headers['Expires'] = '0';
+            return {
+              headers,
+              path: responseArg.path,
+              responseContent: Buffer.from(fileString),
+            };
+          },
+          serveIndexHtmlDefault: true,
+          enableCompression: this.options.enableCompression,
+          preferredCompressionMethod: this.options.preferredCompressionMethod,
+        })
+      );
+    } else if (this.options.injectReload) {
+      throw new Error(
+        'You set to inject the reload script without a serve dir. This is not supported at the moment.'
+      );
+    }
+    if (this.options.watch && 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();
        this.reload();
      });
+      await this.createServeDirHash();
    }

-    await this.createServeDirHash();
-
    // lets start the server
-    await this.smartexpressInstance.start();
-    console.log('open url in browser');
+    await this.server.start();

    this.typedsocket = await plugins.typedsocket.TypedSocket.createServer(
      this.typedrouter,
-      this.smartexpressInstance
+      this.server
    );

+    // lets setup typedrouter
+    this.typedrouter.addTypedHandler<interfaces.IReq_GetLatestServerChangeTime>(
+      new plugins.typedrequest.TypedHandler('getLatestServerChangeTime', async (reqDataArg) => {
+        return {
+          time: this.lastReload,
+        };
+      })
+    );
+
+    // console.log('open url in browser');
    // await plugins.smartopen.openUrl(`http://testing.git.zone:${this.options.port}`);
  }

@ -142,7 +213,9 @@ export class TypedServer {
   */
  public async reload() {
    this.lastReload = Date.now();
-    for (const connectionArg of await this.typedsocket.findAllTargetConnections(async () => true)) {
+    for (const connectionArg of await this.typedsocket.findAllTargetConnectionsByTag(
+      'typedserver_frontend'
+    )) {
      const pushTime =
        this.typedsocket.createTypedRequest<interfaces.IReq_PushLatestServerChangeTime>(
          'pushLatestServerChangeTime',
@ -156,9 +229,11 @@ export class TypedServer {

  public async stop() {
    this.ended = true;
-    await this.smartexpressInstance.stop();
+    await this.server.stop();
    await this.typedsocket.stop();
-    await this.smartchokInstance.stop();
+    if (this.smartchokInstance) {
+      await this.smartchokInstance.stop();
+    }
  }

  public async 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,36 +0,0 @@
-// node native
-import * as path from 'path';
-
-export { path };
-
-// @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 smartchok from '@pushrocks/smartchok';
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartexpress from '@pushrocks/smartexpress';
-import * as smartfile from '@pushrocks/smartfile';
-import * as smartopen from '@pushrocks/smartopen';
-import * as smartpath from '@pushrocks/smartpath';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartrx from '@pushrocks/smartrx';
-
-export {
-  smartchok,
-  smartdelay,
-  smartexpress,
-  smartfile,
-  smartopen,
-  smartpath,
-  smartpromise,
-  smartrx,
-};
--- a/ts_web/00_commitinfo_data.ts
+++ b/ts_web/00_commitinfo_data.ts
@ -2,7 +2,7 @@
 * autocreated commitinfo by @pushrocks/commitinfo
 */
 export const commitinfo = {
-  name: '@apiglobal/typedserver',
-  version: '2.0.35',
-  description: 'easy serving of static files'
+  name: '@api.global/typedserver',
+  version: '3.0.28',
+  description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }
--- a/ts_web/index.ts
+++ b/ts_web/index.ts
@ -61,11 +61,15 @@ export class ReloadChecker {

  public async checkReload(lastServerChange: number) {
    let reloadJustified = false;
-    (await this.store.get(this.storeKey)) !== lastServerChange ? (reloadJustified = true) : null;
+    let storedLastServerChange = await this.store.get(this.storeKey);
+    if (storedLastServerChange && storedLastServerChange !== lastServerChange) {
+      reloadJustified = true;
+    } else {
+    }

    if (reloadJustified) {
      this.store.set(this.storeKey, lastServerChange);
-      const reloadText = `about to reload ${
+      const reloadText = `upgrading... ${
        globalThis.globalSw ? '(purging the sw cache first...)' : ''
      }`;
      this.infoscreen.setText(reloadText);
@ -98,8 +102,29 @@ export class ReloadChecker {
        this.typedrouter,
        plugins.typedsocket.TypedSocket.useWindowLocationOriginUrl()
      );
-      this.typedsocket;
-      logger.log('success', `ReloadChecker connected through typedsocket!`)
+      this.typedsocket.addTag('typedserver_frontend', {});
+      this.typedsocket.eventSubject.subscribe(async (eventArg) => {
+        console.log(`typedsocket event subscription: ${eventArg}`);
+        if (
+          eventArg === 'disconnected' ||
+          eventArg === 'disconnecting' ||
+          eventArg === 'timedOut'
+        ) {
+          this.backendConnectionLost = true;
+          this.infoscreen.setText(`typedsocket ${eventArg}!`);
+        } else if (eventArg === 'connected' && this.backendConnectionLost) {
+          this.backendConnectionLost = false;
+          this.infoscreen.setSuccess('typedsocket connected!');
+          // lets check if a reload is necessary
+          const getLatestServerChangeTime =
+            this.typedsocket.createTypedRequest<interfaces.IReq_GetLatestServerChangeTime>(
+              'getLatestServerChangeTime'
+            );
+          const response = await getLatestServerChangeTime.fire({});
+          this.checkReload(response.time);
+        }
+      });
+      logger.log('success', `ReloadChecker connected through typedsocket!`);
    }
  }

--- a/ts_web/typedserver_web.infoscreen.ts
+++ b/ts_web/typedserver_web.infoscreen.ts
@ -71,6 +71,7 @@ export class TypedserverInfoscreen extends LitElement {
  ];

  public setText(textArg: string) {
+    this.success = false;
    this.text = textArg;
    this.show();
    this.success = false;
@ -80,18 +81,27 @@ export class TypedserverInfoscreen extends LitElement {
    this.text = textArg;
    this.show();
    this.success = true;
+    setTimeout(() => this.hide(), 1000);
  }

  private appended = false;
-  public show () {
-    this.appended = true;
+  public async show () {
    document.body.append(this);
+    this.appended = true;
+    await plugins.smartdelay.delayFor(0);
+    const mainbox = this.shadowRoot.querySelector('.mainbox');
+    mainbox.classList.add('show');
  }

-  public hide() {
-    this.success = false;
+  public async hide() {
    this.text = '';
    if (this.appended) {
+      const mainbox = this.shadowRoot.querySelector('.mainbox');
+      mainbox.classList.remove('show');
+    }
+    await plugins.smartdelay.delayFor(300);
+    if (this.appended) {
+      this.appended = false;
      document.body.removeChild(this);
    }
  }
@ -99,7 +109,7 @@ export class TypedserverInfoscreen extends LitElement {

  public render () {
    return html`
-      <div class="mainbox ${this.show ? 'show' : ''} ${this.success ? 'success': ''}">${this.text}</div>
+      <div class="mainbox ${this.success ? 'success': ''}">${this.text}</div>
    `
  }

--- a/ts_web/typedserver_web.plugins.ts
+++ b/ts_web/typedserver_web.plugins.ts
@ -1,6 +1,6 @@
 // @apiglobal scope
-import * as typedrequest from '@apiglobal/typedrequest';
-import * as typedsocket from '@apiglobal/typedsocket';
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedsocket from '@api.global/typedsocket';

 export {
  typedrequest,
@ -8,10 +8,10 @@ export {
 }

 // 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';
+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,
--- a/tsconfig.json
+++ b/tsconfig.json
@ -1,8 +1,14 @@
 {
  "compilerOptions": {
    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "nodenext"
-  }
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
 }
Author	SHA1	Message	Date
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
Philipp Kunz	ec4a51668c	2.0.57	2023-07-01 12:29:36 +02:00
Philipp Kunz	07739bec27	fix(core): update	2023-07-01 12:29:35 +02:00
Philipp Kunz	9aebd59c08	2.0.56	2023-07-01 11:55:35 +02:00
Philipp Kunz	be7f4c503e	fix(core): update	2023-07-01 11:55:35 +02:00
Philipp Kunz	e1e1d4bf65	2.0.55	2023-07-01 11:49:40 +02:00
Philipp Kunz	20ecb86a9e	fix(core): update	2023-07-01 11:49:39 +02:00
Philipp Kunz	83890d7cab	2.0.54	2023-06-12 01:06:22 +02:00
Philipp Kunz	4c87ea8273	fix(core): update	2023-06-12 01:06:21 +02:00
Philipp Kunz	4be625a0d9	2.0.53	2023-04-10 00:55:17 +02:00
Philipp Kunz	c305ca517a	fix(core): update	2023-04-10 00:55:16 +02:00
Philipp Kunz	23dccae01b	2.0.52	2023-04-09 23:04:36 +02:00
Philipp Kunz	d5f8d215a2	fix(core): update	2023-04-09 23:04:35 +02:00
Philipp Kunz	3d4f8d1bbe	2.0.51	2023-04-04 17:23:50 +02:00
Philipp Kunz	4724629efa	fix(core): update	2023-04-04 17:23:49 +02:00
Philipp Kunz	ff9aea12c3	2.0.50	2023-04-04 17:14:54 +02:00
Philipp Kunz	910b9a495e	fix(core): update	2023-04-04 17:14:54 +02:00
Philipp Kunz	7fdf0a71a7	2.0.49	2023-04-01 15:12:55 +02:00
Philipp Kunz	bf2c6660f2	fix(core): update	2023-04-01 15:12:54 +02:00
Philipp Kunz	49afc16422	2.0.48	2023-03-31 18:04:22 +02:00
Philipp Kunz	bb6f239075	fix(core): update	2023-03-31 18:04:21 +02:00
Philipp Kunz	5bd5916696	2.0.47	2023-03-31 15:27:00 +02:00
Philipp Kunz	62df38d083	fix(core): update	2023-03-31 15:26:59 +02:00
Philipp Kunz	d7fe947107	2.0.46	2023-03-31 15:10:43 +02:00
Philipp Kunz	dd426a4ca4	fix(core): update	2023-03-31 15:10:42 +02:00
Philipp Kunz	2a2d4dabe4	2.0.45	2023-03-31 13:18:23 +02:00
Philipp Kunz	830682d382	fix(core): update	2023-03-31 13:18:23 +02:00
Philipp Kunz	d160a92bee	2.0.44	2023-03-30 19:44:44 +02:00
Philipp Kunz	cc421c3321	fix(core): update	2023-03-30 19:44:44 +02:00
Philipp Kunz	92ecef30d3	2.0.43	2023-03-30 19:42:55 +02:00
Philipp Kunz	de4aab6df0	fix(core): update	2023-03-30 19:42:55 +02:00
Philipp Kunz	5624e9dc1f	2.0.42	2023-03-30 19:40:41 +02:00
Philipp Kunz	c7e40e4cde	fix(core): update	2023-03-30 19:40:41 +02:00
Philipp Kunz	0704febfc0	2.0.41	2023-03-30 17:44:10 +02:00
Philipp Kunz	b8b1a61ae5	fix(core): update	2023-03-30 17:44:10 +02:00
Philipp Kunz	45155bbce0	2.0.40	2023-03-30 16:44:46 +02:00
Philipp Kunz	35bcf717cb	fix(core): update	2023-03-30 16:44:45 +02:00
Philipp Kunz	4d3be1064d	2.0.39	2023-03-30 16:42:02 +02:00
Philipp Kunz	8ee72f9380	fix(core): update	2023-03-30 16:42:02 +02:00
Philipp Kunz	049ceb7d15	2.0.38	2023-03-30 15:15:49 +02:00
Philipp Kunz	87a5337db3	fix(core): update	2023-03-30 15:15:48 +02:00
Philipp Kunz	2372e36367	2.0.37	2023-03-30 12:17:42 +02:00
Philipp Kunz	748fc931c6	fix(core): update	2023-03-30 12:17:41 +02:00
Philipp Kunz	d5cdb94c73	2.0.36	2023-03-29 19:51:53 +02:00
Philipp Kunz	59d6c7d5ec	fix(core): update	2023-03-29 19:51:52 +02:00