v4.1.0

- Removed legacy servertools and Express dependencies in favor of SmartServe.
- Introduced DevToolsHandler and TypedRequestHandler for handling specific routes.
- Added support for custom route registration with regex parsing.
- Implemented sitemap and feed handling with dedicated helper classes.
- Enhanced HTML response handling with reload script injection.
- Updated UtilityServiceServer and UtilityWebsiteServer to utilize new TypedServer API.
- Removed deprecated compression options and Express-based route handling.
- Added comprehensive request handling for various endpoints including robots.txt, manifest.json, and sitemap.
- Improved error handling and response formatting across the server.

.gitlab-ci.yml

@@ -1,128 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-before_script:
-  - pnpm install -g pnpm
-  - pnpm install -g @shipzone/npmci
-  - npmci npm prepare
-
-# ====================
-# security stage
-# ====================
-# ====================
-# security stage
-# ====================
-auditProductionDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-     - npmci command npm config set registry https://registry.npmjs.org
-     - npmci command pnpm audit --audit-level=high --prod
-  tags:
-    - lossless
-    - docker
-  allow_failure: true
-
-auditDevDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command pnpm audit --audit-level=high --dev
-  tags:
-    - lossless
-    - docker
-  allow_failure: true
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-testBuild:
-  stage: test
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  only:
-    - tags
-  script:
-    - npmci command npm install -g typescript
-    - npmci npm prepare
-    - npmci npm install
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run buildDocs
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true

.serena/.gitignore

@@ -0,0 +1 @@
+/cache

.serena/project.yml

@@ -0,0 +1,68 @@
+# language of the project (csharp, python, rust, java, typescript, go, cpp, or ruby)
+#  * For C, use cpp
+#  * For JavaScript, use typescript
+# Special requirements:
+#  * csharp: Requires the presence of a .sln file in the project folder.
+language: typescript
+
+# whether to use the project's gitignore file to ignore files
+# Added on 2025-04-07
+ignore_all_files_in_gitignore: true
+# list of additional paths to ignore
+# same syntax as gitignore, so you can use * and **
+# Was previously called `ignored_dirs`, please update your config if you are using that.
+# Added (renamed) on 2025-04-07
+ignored_paths: []
+
+# whether the project is in read-only mode
+# If set to true, all editing tools will be disabled and attempts to use them will result in an error
+# Added on 2025-04-18
+read_only: false
+
+
+# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
+# Below is the complete list of tools for convenience.
+# To make sure you have the latest list of tools, and to view their descriptions, 
+# execute `uv run scripts/print_tool_overview.py`.
+#
+#  * `activate_project`: Activates a project by name.
+#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
+#  * `create_text_file`: Creates/overwrites a file in the project directory.
+#  * `delete_lines`: Deletes a range of lines within a file.
+#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
+#  * `execute_shell_command`: Executes a shell command.
+#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
+#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
+#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file.
+#  * `initial_instructions`: Gets the initial instructions for the current project.
+#     Should only be used in settings where the system prompt cannot be set,
+#     e.g. in clients you have no control over, like Claude Desktop.
+#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
+#  * `insert_at_line`: Inserts content at a given line in a file.
+#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
+#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
+#  * `list_memories`: Lists memories in Serena's project-specific memory store.
+#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
+#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
+#  * `read_file`: Reads a file within the project directory.
+#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
+#  * `remove_project`: Removes a project from the Serena configuration.
+#  * `replace_lines`: Replaces a range of lines within a file with new content.
+#  * `replace_symbol_body`: Replaces the full definition of a symbol.
+#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
+#  * `search_for_pattern`: Performs a search for a pattern in the project.
+#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
+#  * `switch_modes`: Activates modes by providing a list of their names
+#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
+#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
+#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
+#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
+excluded_tools: []
+
+# initial prompt for the project. It will always be given to the LLM upon activating the project
+# (contrary to the memories, which are loaded on demand).
+initial_prompt: ""
+
+project_name: "typedserver"

changelog.md

@@ -0,0 +1,421 @@
+# Changelog
+
+## 2025-12-02 - 4.1.0 - feat(TypedServer)
+Integrate SmartServe controller routing; add built-in routes controller and refactor TypedServer to use controllers and FileServer
+
+- Add BuiltInRoutesController exposing /robots.txt, /manifest.json, /sitemap, /sitemap-news, /feed and /appversion
+- Refactor TypedRequestHandler into a SmartServe-decorated TypedRequestController and register it with ControllerRegistry
+- Refactor TypedServer to use SmartServe: register controller instances, use ControllerRegistry matching, and delegate WebSocket integration to SmartServe
+- Introduce FileServer-based static serving with HTML reload script injection and improved default root handling
+- Expand supported HTTP methods to include HEAD and OPTIONS
+- Remove legacy FeedHelper and consolidate sitemap/feed handling into controllers and helpers
+- Enhance servertools legacy Express utilities: improved HandlerProxy, HandlerStatic, Compressor with caching and preferred compression support
+- Service worker subsystem improvements: CacheManager, NetworkManager, UpdateManager and backend enhancements for robust caching, revalidation and client reloads
+- Web-inject LitElement properties switched from private fields to accessor syntax (typedserver_web.infoscreen)
+
+## 2025-12-02 - 4.0.0 - BREAKING CHANGE(typedserver)
+Migrate to new push.rocks packages and async smartfs API; replace smartchok with smartwatch; update deps and service worker handling
+
+- Major dependency updates: @push.rocks packages upgraded (smartfile -> v13, smartfs added v1.2.0, smartenv v6, smartrequest v5, smartwatch v5, webrequest v4), Express and dev-tooling bumped.
+- Replace sync smartfile APIs with async SmartFs instance (plugins.fsInstance). All file reads now use async smartfs calls.
+- smartfile v13 migration: removed sync fs helpers; added plugins.fsInstance (SmartFs + Node provider).
+- Renamed file watcher usage: Smartchok -> Smartwatch and property names updated (smartwatchInstance).
+- WebRequest class rename handled: WebRequest -> WebrequestClient (webrequest v4).
+- Service worker bundle is lazy-loaded (avoid startup sync file reads) and added routes for bundle and source map.
+- Service worker & SW-related improvements: more robust caching, enhanced cache headers, offline handling, revalidation, and update forcing logic.
+- createServeDirHash now uses smartfs.directory().recursive().treeHash() and truncates hash to 12 chars; fallback hash logic retained.
+- HandlerStatic, HandlerProxy and route handling hardened for Express 5 wildcard params (array/various shapes supported).
+- Various runtime improvements: safer start/stop handling, improved error logging, and non-blocking initialization of optional features (file watcher, TypedSocket).
+- Updated tooling/dev deps: @git.zone/tsbuild/tsbundle/tstest and @types/node updated.
+
+## 2025-11-19 - 3.0.80 - fix(dependencies)
+Bump dependencies and devDependencies to updated versions
+
+- Upgrade @push.rocks/smartfeed: ^1.0.11 → ^1.4.0
+- Upgrade @push.rocks/smartfile: ^11.2.5 → ^11.2.7
+- Upgrade @push.rocks/smartjson: ^5.0.20 → ^5.2.0
+- Upgrade @push.rocks/smartlog: ^3.1.8 → ^3.1.10
+- Upgrade @push.rocks/smartsitemap: ^2.0.3 → ^2.0.4
+- Upgrade @push.rocks/taskbuffer: ^3.1.7 → ^3.4.0
+- Upgrade @tsclass/tsclass: ^9.2.0 → ^9.3.0
+- Upgrade @types/express: ^5.0.3 → ^5.0.5
+- Dev: Upgrade @git.zone/tsbuild: ^2.6.4 → ^3.1.0
+- Dev: Upgrade @git.zone/tsbundle: ^2.5.1 → ^2.5.2
+- Dev: Upgrade @git.zone/tsrun: ^1.3.3 → ^2.0.0
+- Dev: Upgrade @git.zone/tstest: ^2.3.4 → ^2.8.2
+
+## 2025-09-03 - 3.0.79 - fix(servertools)
+Normalize Express wildcard parameter notation to /{*splat} across server routes and handlers; add local Claude settings
+
+- Replaced route pattern '/*splat' with '/{*splat}' in ts/classes.typedserver.ts and ts/servertools/tools.sslredirect.ts
+- Updated Express options route to use '/{*splat}' in ts/servertools/classes.server.ts
+- Clarified wildcard handling comments and array-join logic for splat params in ts/servertools/classes.handlerproxy.ts and ts/servertools/classes.handlerstatic.ts
+- Added .claude/settings.local.json containing local tool permissions for Claude/dev onboarding
+- No functional API changes — routing pattern normalization and comment/handler improvements only
+
+## 2025-09-03 - 3.0.78 - fix(servertools)
+Fix wildcard path extraction for static/proxy handlers, correct serviceworker route, add local settings and test typo fix
+
+- Make HandlerProxy and HandlerStatic robust to Express 5 wildcard param shapes (handle req.params.splat, numeric params, req.baseUrl and root routes) to correctly compute relative paths
+- Change serviceworker route registration to use '/serviceworker/*splat' (instead of previous pattern) for consistent wildcard handling
+- Fix test wording typo in test/test.server.ts ('exposer' -> 'expose')
+- Add .claude/settings.local.json with local tool permissions and add .serena/.gitignore to ignore /cache
+
+## 2025-08-17 - 3.0.77 - fix(servertools)
+Adjust route wildcard patterns and CORS handling; update serviceworker and SSL redirect patterns; bump express dependency; add local Claude settings
+
+- Normalize route wildcard patterns to use splat tokens (e.g. '/someroute/*' -> '/someroute/*splat', '/*' -> '/*splat') for consistent route matching
+- Update serviceworker route registration to '/serviceworker{.*}' and adjust related handler
+- Change SSL redirect route from '*' to '/*splat'
+- Adjust CORS preflight options path to '/*splat' and update tests to reflect new route patterns
+- Bump express dependency from ^4.21.2 to ^5.1.0
+- Add .claude/settings.local.json for local Claude tool permissions
+
+## 2025-08-16 - 3.0.76 - fix(handlerproxy)
+Use SmartRequest API and improve proxy/asset response handling; update tests and bump dependencies; add local project configuration files
+
+- Replace deprecated smartrequest.request usage with SmartRequest fluent API in ts/servertools/classes.handlerproxy.ts and add explicit handling for GET/POST/PUT/DELETE/PATCH methods.
+- Normalize proxied response body handling by using arrayBuffer()/text() and converting to Buffer to avoid body type inconsistencies.
+- Switch asset fetching in ts/utilityservers/classes.websiteserver.ts to SmartRequest + arrayBuffer for reliable binary handling.
+- Update tests (test/test.server.ts) to use SmartRequest.create() and to read response bodies via response.text(), matching the updated request API.
+- Bump dependencies: @push.rocks/smartrequest -> ^4.2.1 and body-parser -> ^2.2.0.
+- Add local project configuration files: .claude/settings.local.json and .serena/project.yml.
+
+## 2025-08-16 - 3.0.75 - fix(deps)
+Update dependencies, test tooling and test imports; enhance npm test script
+
+- Bump multiple runtime dependencies to newer patch/minor versions (notable updates: @cloudflare/workers-types, @push.rocks/* packages such as smartchok, smartfile, smartlog, smartpath, smartrx, and others, @tsclass/tsclass, @types/express, lit).
+- Upgrade dev tooling versions: @git.zone/tsbuild and @git.zone/tsbundle; update @git.zone/tstest to v2.3.4.
+- Improve npm test script by adding --verbose, --logfile and increased --timeout.
+- Fix test imports to use @git.zone/tstest/tapbundle in test/test.reload.ts and test/test.server.ts.
+
+## 2025-04-12 - 3.0.74 - fix(commit-info)
+chore: update commit metadata (no source code changes)
+
+- Uncommitted diff shows no changes in source files; the commit updates internal commit info only.
+
+## 2025-04-11 - 3.0.73 - fix(metadata)
+Update repository URLs and metadata to reflect the new organization scope
+
+- Changed gitscope from 'pushrocks' to 'api.global' in npmextra.json
+- Updated repository URL, bugs URL, and homepage in package.json to use code.foss.global/api.global/typedserver
+
+## 2025-04-11 - 3.0.72 - fix(project)
+chore: no changes - commit metadata update
+
+
+## 2025-04-11 - 3.0.71 - fix(serviceworker)
+Improve error handling and logging in service worker backend and network manager; update multiple dependency versions and packageManager settings.
+
+- Upgrade dependency versions in package.json (e.g. @cloudflare/workers-types, @push.rocks/smartfile, @push.rocks/smartpromise, @push.rocks/smartrequest, @tsclass/tsclass, and @types/express)
+- Add packageManager field to package.json
+- Enhance error handling in ServiceworkerBackend (using try/catch and detailed logging) during client reload, notification display, and alert message sending
+- Improve network request handling by clearing timeouts and converting errors reliably in NetworkManager
+- Wrap service worker install and activate event handlers with try/catch to log errors appropriately
+
+## 2025-03-16 - 3.0.70 - fix(TypedServer)
+Improve error handling in server startup and response buffering. Validate configuration for reload injections, wrap file watching and TypedSocket initialization in try/catch blocks, enhance client notification and stop procedures, and ensure proper Buffer conversion in the proxy handler.
+
+- Add validation to throw error if reload script is enabled without a serve directory
+- Wrap file watching and TypedSocket initialization in try/catch to prevent crashes during startup
+- Update the reload function to safely notify clients and handle notification errors
+- Enhance the stop procedure to aggregate cleanup tasks with error handling
+- Ensure consistent conversion of response bodies to Buffer in HandlerProxy with fallback when undefined
+- Include fallback hash generation in createServeDirHash for error resilience
+
+## 2025-03-16 - 3.0.69 - fix(servertools)
+Fix compression stream creation returns, handler proxy buffer conversion, and sitemap URL concatenation
+
+- Return compression stream immediately in createCompressionStream for each case instead of using break statements
+- Convert proxied response to a Buffer in handler proxy rather than throwing an error when it isn't a string
+- Fix addUrls method in sitemap to correctly concatenate new URLs without duplicating existing entries
+
+## 2025-02-07 - 3.0.68 - fix(cache-manager)
+Simplify cache control headers in cache manager
+
+- Removed unnecessary cache control headers while setting modern Cache-Control.
+
+## 2025-02-06 - 3.0.67 - fix(serviceworker)
+Enhance header security for cached resources in service worker
+
+- Added Cross-Origin-Resource-Policy header management for service worker cached resources.
+
+## 2025-02-06 - 3.0.66 - fix(serviceworker)
+Improve error handling and logging in cache manager and update manager.
+
+- Enhanced error handling and logging in cache management functions.
+- Corrected network request handling in update manager.
+- Added missing error handling for fetch events.
+
+## 2025-02-04 - 3.0.65 - fix(readme)
+Update documentation with advanced usage and examples
+
+- Added section on advanced usage including service worker and edge worker setup
+- Detailed integration examples for type-safe API requests and WebSocket communication
+- Expanded configuration options and cache strategies
+
+## 2025-02-04 - 3.0.64 - fix(serviceworker)
+Improve cache handling and response header management in service worker.
+
+- Addressed issue preventing caching of certain responses due to missing CORS headers.
+- Added 'Vary: Origin' header to ensure proper response handling.
+- Included 'Access-Control-Expose-Headers' for better CORS support.
+
+## 2025-02-04 - 3.0.63 - fix(core)
+Refactored caching strategy for service worker to improve compatibility and performance.
+
+- Removed hard and soft caching distinctions.
+- Simplified cache setup process.
+- Improved browser caching control headers.
+
+## 2025-02-04 - 3.0.62 - fix(Service Worker)
+Refactor and clean up the cache logic in the Service Worker to improve maintainability and handle Safari-specific cache behavior.
+
+- Refactored logic for determining cached domains, enhancing the readability and maintainability of the code.
+- Improved handling of CORS settings in caching requests, notably bypassing caching for soft cached domains in Safari to avoid CORS issues.
+- Enhanced error response creation for failed resource fetching, maintaining clarity on why and how certain resources were not fetched or cached.
+- Revised the structure of the caching logic to ensure consistent behavior across all supported browsers.
+
+## 2025-02-04 - 3.0.61 - fix(ServiceWorkerCacheManager)
+Fixed caching mechanism to better support Safari's handling of soft-cached domains.
+
+- Added logic to differentiate between hard and soft cached domains.
+- Implemented special handling for soft cached domains on Safari by bypassing caching.
+- Ensured appropriate CORS headers are present in cached responses.
+- Improved error handling with informative 500 error responses.
+- Optimized caching logic to prevent redundant caching and potential issues with locked streams on Safari.
+
+## 2025-02-04 - 3.0.61 - fix(ServiceWorkerCacheManager)
+Fixed caching mechanism to better support Safari's handling of soft-cached domains.
+
+- Added logic to differentiate between hard and soft cached domains.
+- Implemented special handling for soft cached domains on Safari by bypassing caching.
+- Ensured appropriate CORS headers are present in cached responses.
+- Improved error handling with informative 500 error responses.
+- Optimized caching logic to prevent redundant caching and potential issues with locked streams on Safari.
+
+## 2025-02-04 - 3.0.61 - fix(ServiceWorkerCacheManager)
+Fixed caching mechanism to better support Safari's handling of soft-cached domains.
+
+- Added logic to differentiate between hard and soft cached domains.
+- Implemented special handling for soft cached domains on Safari by bypassing caching.
+- Ensured appropriate CORS headers are present in cached responses.
+- Improved error handling with informative 500 error responses.
+- Optimized caching logic to prevent redundant caching and potential issues with locked streams on Safari.
+
+## 2025-02-04 - 3.0.60 - fix(cachemanager)
+Improve cache management and error handling
+
+- Updated comments for clarity and consistency.
+- Enhanced error handling in `fetch` event listener.
+- Optimized cache key management and cleanup process.
+- Ensured CORS headers are set for cached responses.
+- Improved logging for caching operations.
+
+## 2025-02-03 - 3.0.59 - fix(serviceworker)
+Fixed CORS and Cache Control handling for Service Worker
+
+- Improved handling of CORS settings for external requests.
+- Preserved important headers while excluding caching headers.
+- Ensured the presence of CORS headers in cached responses.
+- Adjusted Cache-Control headers to prevent browser caching but allow service worker caching.
+
+## 2025-02-03 - 3.0.58 - fix(network-manager)
+Refined network management logic for better offline handling.
+
+- Improved logic to handle missing connections more gracefully.
+- Added detailed online/offline connection status logging.
+- Implemented a check for stale cache with a grace period for offline scenarios.
+- Network requests now use optimized retries and timeouts.
+
+## 2025-02-03 - 3.0.57 - fix(updateManager)
+Refine cache management for service worker updates.
+
+- Ensured cache is forcibly updated if older than defined maximum age.
+- Implemented interval checks and forced updates for cache staleness.
+- Updated version information and cache timestamps upon forced updates or validations.
+
+## 2025-02-03 - 3.0.56 - fix(cachemanager)
+Adjust cache control headers and fix redundant code
+
+- Remove duplicate assetbroker URLs in the cache evaluation logic.
+- Update cache control headers to improve caching behavior.
+- Increase the timeout for fetch operations to improve compatibility.
+
+## 2025-01-28 - 3.0.55 - fix(server)
+Fix response content manipulation for HTML files with injectReload
+
+- Moved fileString declaration inside HTML file handling block to prevent unnecessary string conversion for non-HTML files.
+- Corrected responseContent assignment to ensure modified HTML strings are converted back to Buffer format.
+
+## 2025-01-28 - 3.0.54 - fix(servertools)
+Fixed an issue with compression results handling in HandlerStatic where content was always being written even if not compressed.
+
+- Corrected the double writing of response in HandlerStatic.
+- Ensured that file buffers are only conditionally written based on compression availability.
+
+## 2024-12-26 - 3.0.53 - fix(infohtml)
+Remove Sentry script and logo from HTML template
+
+- Removed Sentry script from the HTML template.
+- Removed Lossless GmbH logo and contact info.
+- Updated footer link to point to foss.global.
+
+## 2024-12-25 - 3.0.52 - fix(dependencies)
+Bump package versions in dependencies and exports.
+
+- Updated package dependencies to their latest versions.
+- Added './infohtml' in package exports.
+
+## 2024-08-27 - 3.0.51 - fix(core)
+Update dependencies and fix service worker cache manager and task manager functionalities
+
+- Updated dependencies in package.json to their latest versions
+- Enhanced service worker cache manager to include additional scoped URLs
+- Fixed task manager to start the task manager and added update task functionality
+- Removed .gitlab-ci.yml from the repository as part of the cleanup
+
+## 2024-05-25 - 3.0.43 to 3.0.50 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.43 to 3.0.50
+
+## 2024-05-23 - 3.0.37 to 3.0.42 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.37 to 3.0.42
+
+## 2024-05-17 - 3.0.37 - Core
+Routine update and bug fix
+
+- Updated core functionalities
+
+## 2024-05-14 - 3.0.33 to 3.0.36 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.33 to 3.0.36
+
+## 2024-05-13 - 3.0.31 to 3.0.32 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.31 to 3.0.32
+
+## 2024-05-11 - 3.0.29 to 3.0.31 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.29 to 3.0.31
+
+## 2024-04-19 - 3.0.27 to 3.0.28 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.27 to 3.0.28
+
+## 2024-04-14 - 3.0.27 - Documentation
+Updated Documentation
+
+- Improved and updated documentation
+
+## 2024-03-01 - 3.0.25 to 3.0.26 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.25 to 3.0.26
+
+## 2024-02-21 - 3.0.20 to 3.0.24 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.20 to 3.0.24
+
+## 2024-01-19 - 3.0.19 to 3.0.20 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.19 to 3.0.20
+
+## 2024-01-09 - 3.0.14 to 3.0.18 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.14 to 3.0.18
+
+## 2024-01-08 - 3.0.11 to 3.0.13 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.11 to 3.0.13
+
+## 2024-01-07 - 3.0.9 to 3.0.10 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.9 to 3.0.10
+
+## 2023-11-06 - 3.0.8 to 3.0.9 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.8 to 3.0.9
+
+## 2023-10-23 - 3.0.6 to 3.0.7 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.6 to 3.0.7
+
+## 2023-10-20 - 3.0.5 to 3.0.6 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.5 to 3.0.6
+
+## 2023-09-21 - 3.0.4 to 3.0.5 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.4 to 3.0.5
+
+## 2023-08-06 - 3.0.2 to 3.0.3 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.2 to 3.0.3
+
+## 2023-08-03 - 3.0.1 to 3.0.0 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.1 to 3.0.0
+
+## 2023-08-03 - 2.0.65 - Core
+Breaking change in core update
+
+- Introduced breaking changes updating core functionalities
+
+## 2023-07-02 - 2.0.59 to 2.0.64 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.59 to 2.0.64
+
+## 2023-07-01 - 2.0.54 to 2.0.58 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.54 to 2.0.58
+
+## 2023-06-12 - 2.0.53 - Core
+Routine update and bug fix
+
+- Updated core functionalities
+
+## 2023-04-10 - 2.0.52 to 2.0.53 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.52 to 2.0.53
+
+## 2023-04-04 - 2.0.49 to 2.0.51 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.49 to 2.0.51
+
+## 2023-03-31 - 2.0.45 to 2.0.48 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.45 to 2.0.48
+
+## 2023-03-30 - 2.0.37 to 2.0.44 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.37 to 2.0.44
+
+## 2023-03-29 - 2.0.33 to 2.0.36 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.33 to 2.0.36

npmextra.json

@@ -5,12 +5,31 @@
   "gitzone": {
     "projectType": "npm",
     "module": {
-      "githost": "gitlab.com",
-      "gitscope": "pushrocks",
+      "githost": "code.foss.global",
+      "gitscope": "api.global",
       "gitrepo": "typedserver",
-      "description": "easy serving of static files",
+      "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
       "npmPackagename": "@api.global/typedserver",
-      "license": "MIT"
+      "license": "MIT",
+      "keywords": [
+        "TypeScript",
+        "static file serving",
+        "live reload",
+        "compression",
+        "typed requests",
+        "HTTP server",
+        "SSL",
+        "cors",
+        "express middleware",
+        "proxy",
+        "sitemap",
+        "feeds",
+        "robots.txt",
+        "compression (gzip, deflate, brotli)"
+      ]
     }
+  },
+  "tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
   }
 }

package.json

@@ -1,27 +1,48 @@
 {
   "name": "@api.global/typedserver",
-  "version": "3.0.7",
-  "description": "easy serving of static files",
-  "main": "dist_ts/index.js",
-  "typings": "dist_ts/index.d.ts",
+  "version": "4.1.0",
+  "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
   "type": "module",
+  "exports": {
+    ".": "./dist_ts/index.js",
+    "./infohtml": "./dist_ts/infohtml/index.js",
+    "./backend": "./dist_ts/index.js",
+    "./edgeworker": "./dist_ts_edgeworker/index.js",
+    "./web_inject": "./dist_ts_web_inject/index.js",
+    "./web_serviceworker": "./dist_ts_web_serviceworker/index.js",
+    "./web_serviceworker_client": "./dist_ts_web_serviceworker_client/index.js"
+  },
   "scripts": {
-    "test": "npm run build && tstest test/",
-    "build": "tsbuild --web --allowimplicitany && tsbundle --from ./ts_web/index.ts --to ./dist_ts_web/bundle.js",
-    "buildDocs": "tsdoc"
+    "test": "npm run build && tstest test/ --verbose --logfile --timeout 60",
+    "build": "tsbuild tsfolders --web --allowimplicitany && npm run bundle",
+    "bundle": "tsbundle --from ./ts_web_inject/index.ts --to ./dist_ts_web_inject/bundle.js && tsbundle --from ./ts_web_serviceworker/index.ts --to ./dist_ts_web_serviceworker/serviceworker.bundle.js",
+    "interfaces": "tsbuild interfaces --web --allowimplicitany --skiplibcheck",
+    "docs": "tsdoc aidoc"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/pushrocks/easyserve.git"
+    "url": "https://code.foss.global/api.global/typedserver.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",
   "bugs": {
-    "url": "https://github.com/pushrocks/easyserve/issues"
+    "url": "https://code.foss.global/api.global/typedserver/issues"
   },
   "files": [
     "ts/**/*",
@@ -35,47 +56,58 @@
     "npmextra.json",
     "readme.md"
   ],
-  "homepage": "https://github.com/pushrocks/easyserve",
+  "homepage": "https://code.foss.global/api.global/typedserver",
   "dependencies": {
-    "@api.global/typedrequest": "^3.0.2",
-    "@api.global/typedrequest-interfaces": "^3.0.1",
-    "@api.global/typedsocket": "^3.0.0",
-    "@push.rocks/lik": "^6.0.5",
-    "@push.rocks/smartchok": "^1.0.23",
+    "@api.global/typedrequest": "^3.1.10",
+    "@api.global/typedrequest-interfaces": "^3.0.19",
+    "@api.global/typedsocket": "^3.1.1",
+    "@cloudflare/workers-types": "^4.20251202.0",
+    "@design.estate/dees-comms": "^1.0.27",
+    "@push.rocks/lik": "^6.2.2",
     "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartenv": "^5.0.10",
-    "@push.rocks/smartfeed": "^1.0.11",
-    "@push.rocks/smartfile": "^10.0.33",
-    "@push.rocks/smartlog": "^3.0.3",
-    "@push.rocks/smartlog-destination-devtools": "^1.0.10",
+    "@push.rocks/smartenv": "^6.0.0",
+    "@push.rocks/smartfeed": "^1.4.0",
+    "@push.rocks/smartfile": "^13.1.0",
+    "@push.rocks/smartfs": "^1.2.0",
+    "@push.rocks/smartjson": "^5.2.0",
+    "@push.rocks/smartlog": "^3.1.10",
+    "@push.rocks/smartlog-destination-devtools": "^1.0.12",
+    "@push.rocks/smartlog-interfaces": "^3.0.2",
     "@push.rocks/smartmanifest": "^2.0.2",
-    "@push.rocks/smartmime": "^1.0.5",
+    "@push.rocks/smartmatch": "^2.0.0",
+    "@push.rocks/smartmime": "^2.0.4",
+    "@push.rocks/smartntml": "^2.0.8",
     "@push.rocks/smartopen": "^2.0.0",
-    "@push.rocks/smartpath": "^5.0.11",
-    "@push.rocks/smartpromise": "^4.0.2",
-    "@push.rocks/smartrequest": "^2.0.18",
-    "@push.rocks/smartrx": "^3.0.6",
-    "@push.rocks/smartsitemap": "^2.0.3",
-    "@push.rocks/smarttime": "^4.0.6",
-    "@push.rocks/webstore": "^2.0.13",
-    "@tsclass/tsclass": "^4.0.46",
-    "@types/express": "^4.17.20",
-    "body-parser": "^1.20.2",
+    "@push.rocks/smartpath": "^6.0.0",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartrequest": "^5.0.1",
+    "@push.rocks/smartrx": "^3.0.10",
+    "@push.rocks/smartserve": "^1.1.0",
+    "@push.rocks/smartsitemap": "^2.0.4",
+    "@push.rocks/smartstream": "^3.2.5",
+    "@push.rocks/smarttime": "^4.1.1",
+    "@push.rocks/smartwatch": "^5.0.0",
+    "@push.rocks/taskbuffer": "^3.4.0",
+    "@push.rocks/webrequest": "^4.0.1",
+    "@push.rocks/webstore": "^2.0.20",
+    "@tsclass/tsclass": "^9.3.0",
+    "@types/express": "^5.0.6",
+    "body-parser": "^2.2.1",
     "cors": "^2.8.5",
-    "express": "^4.18.2",
+    "express": "^5.2.1",
     "express-force-ssl": "^0.3.2",
-    "lit": "^3.0.0"
+    "lit": "^3.3.1"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.66",
-    "@git.zone/tsbundle": "^2.0.8",
-    "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.8.7"
+    "@git.zone/tsbuild": "^3.1.2",
+    "@git.zone/tsbundle": "^2.6.2",
+    "@git.zone/tsrun": "^2.0.0",
+    "@git.zone/tstest": "^3.1.3",
+    "@types/node": "^24.10.1"
   },
   "private": false,
   "browserslist": [
     "last 1 chrome versions"
-  ]
+  ],
+  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6"
 }

readme.hints.md

@@ -0,0 +1,41 @@
+# Project Hints - @api.global/typedserver
+
+## Recent Changes (December 2025)
+
+### Dependency Updates
+- `@push.rocks/smartchok` replaced with `@push.rocks/smartwatch` (renamed package, same API)
+- `@push.rocks/smartfile` upgraded from v11 to v13 (major API change - `fs` module removed)
+- `@push.rocks/smartfs` added for filesystem operations (v1.2.0+)
+- `@push.rocks/smartenv` upgraded to v6.0.0
+- `@push.rocks/smartrequest` upgraded to v5.0.1
+- `@push.rocks/webrequest` upgraded to v4.0.1 (`WebRequest` renamed to `WebrequestClient`)
+- Express upgraded to v5.2.1
+- All `@git.zone/*` dev dependencies updated to latest
+
+### Code Migration Notes
+
+#### smartfile v13 Migration
+- Old: `plugins.smartfile.fs.toStringSync(path)` / `plugins.smartfile.fs.toBufferSync(path)`
+- New: Use `plugins.fsInstance` (SmartFs instance with Node provider)
+  - String: `await plugins.fsInstance.file(path).encoding('utf8').read() as string`
+  - Buffer: `await plugins.fsInstance.file(path).read() as Buffer`
+
+#### smartfs treeHash
+- Old: `plugins.smartfile.fs.fileTreeToHash(dir, pattern)`
+- New: `await plugins.fsInstance.directory(dir).recursive().treeHash()`
+
+#### smartwatch (formerly smartchok)
+- Class renamed: `Smartchok` → `Smartwatch`
+- API remains the same: `new Smartwatch([paths])`, `.start()`, `.stop()`, `.getObservableFor(event)`
+
+#### webrequest v4
+- Class renamed: `WebRequest` → `WebrequestClient`
+
+### Architecture
+- `plugins.fsInstance` is a pre-configured SmartFs instance with SmartFsProviderNode
+- All file operations should be async using smartfs
+- Sync file operations have been removed
+
+### Express 5 Notes
+- Wildcard routes use `/{*splat}` notation
+- `req.params.splat` can be an array, use `Array.isArray()` check

readme.md

@@ -1,49 +1,278 @@
-# @pushrocks/typedserver
-easy serving of static files
+# @api.global/typedserver
 
-## 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/)
+A powerful TypeScript-first web server framework featuring static file serving, live reload, compression, and seamless type-safe API integration. Part of the `@api.global` ecosystem, it provides a modern foundation for building full-stack TypeScript applications with first-class support for typed HTTP requests and WebSocket communication.
 
-## Status for master
+## Issue Reporting and Security
 
-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)
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
 
-## Usage
+## ✨ Features
 
-Use TypeScript for best in class instellisense.
+- 🔒 **Type-Safe API Ecosystem** - Full TypeScript support with `@api.global/typedrequest` and `@api.global/typedsocket`
+- ⚡ **Live Reload** - Automatic browser refresh on file changes during development
+- 🗜️ **Compression** - Built-in support for gzip, deflate, and brotli compression
+- 🌐 **CORS Management** - Flexible cross-origin resource sharing configuration
+- 🔧 **Service Worker Integration** - Advanced caching and offline capabilities
+- ☁️ **Edge Worker Support** - Cloudflare Workers compatible edge computing
+- 📡 **WebSocket Support** - Real-time bidirectional communication via TypedSocket
+- 🗺️ **Sitemap & Feeds** - Automatic sitemap and RSS feed generation
+- 🤖 **Robots.txt** - Built-in robots.txt handling
 
-```javascript
-import { TypedServer } from '@apiglobal/typedserver';
+## 📦 Installation
 
-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
-});
+```bash
+# Using pnpm (recommended)
+pnpm add @api.global/typedserver
 
-myTypedserver.reload(); // reloads all connected browsers of this instance
+# Using npm
+npm install @api.global/typedserver
 ```
 
-## Contribution
+## 🚀 Quick Start
 
-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). :)
+### Basic Static File Server
 
-For further information read the linked docs at the top of this readme.
+```typescript
+import { TypedServer } from '@api.global/typedserver';
 
-## Legal
-> MIT licensed | **©** [Task Venture Capital GmbH](https://task.vc)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+const server = new TypedServer({
+  serveDir: './public',
+  cors: true,
+  watch: true,           // Enable file watching
+  injectReload: true,    // Inject live reload script
+});
+
+await server.start();
+console.log('Server running on port 3000');
+```
+
+### Server with All Options
+
+```typescript
+import { TypedServer } from '@api.global/typedserver';
+
+const server = new TypedServer({
+  port: 8080,
+  serveDir: './dist',
+  cors: true,
+  watch: true,
+  injectReload: true,
+  enableCompression: true,
+  preferredCompressionMethod: 'brotli',
+  forceSsl: false,
+  sitemap: true,
+  feed: true,
+  robots: true,
+  domain: 'example.com',
+  appVersion: 'v1.0.0',
+  manifest: {
+    name: 'My App',
+    short_name: 'myapp',
+    start_url: '/',
+    display: 'standalone',
+    background_color: '#ffffff',
+    theme_color: '#000000',
+  },
+});
+
+await server.start();
+```
+
+## 🔌 Type-Safe API Integration
+
+### Adding TypedRequest Handlers
+
+```typescript
+import { TypedServer, servertools } from '@api.global/typedserver';
+import * as typedrequest from '@api.global/typedrequest';
+
+// Define your typed request interface
+interface IGetUser {
+  method: 'getUser';
+  request: { userId: string };
+  response: { name: string; email: string };
+}
+
+const server = new TypedServer({ serveDir: './public', cors: true });
+
+// Create a typed router
+const typedRouter = new typedrequest.TypedRouter();
+
+// Add a typed handler
+typedRouter.addTypedHandler<IGetUser>(
+  new typedrequest.TypedHandler('getUser', async (data) => {
+    // Your logic here
+    return { name: 'John Doe', email: 'john@example.com' };
+  })
+);
+
+// Attach the router to the server
+server.server.addRoute('/api', new servertools.HandlerTypedRouter(typedRouter));
+
+await server.start();
+```
+
+### WebSocket Communication with TypedSocket
+
+```typescript
+import { TypedServer } from '@api.global/typedserver';
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedsocket from '@api.global/typedsocket';
+
+const server = new TypedServer({ serveDir: './public', cors: true });
+const typedRouter = new typedrequest.TypedRouter();
+
+await server.start();
+
+// Create WebSocket server attached to the HTTP server
+const socketServer = await typedsocket.TypedSocket.createServer(
+  typedRouter,
+  server.server
+);
+
+// Handle real-time events
+interface IChatMessage {
+  method: 'sendMessage';
+  request: { text: string; room: string };
+  response: { messageId: string; timestamp: number };
+}
+
+typedRouter.addTypedHandler<IChatMessage>(
+  new typedrequest.TypedHandler('sendMessage', async (data) => {
+    return { messageId: crypto.randomUUID(), timestamp: Date.now() };
+  })
+);
+```
+
+## 🛠️ Server Tools
+
+### Custom Route Handlers
+
+```typescript
+import { servertools } from '@api.global/typedserver';
+
+const server = new servertools.Server({
+  cors: true,
+  domain: 'example.com',
+});
+
+// Add a custom route with handler
+server.addRoute('/api/hello', new servertools.Handler('GET', async (req, res) => {
+  res.json({ message: 'Hello, World!' });
+}));
+
+// Serve static files from a directory
+server.addRoute('/{*splat}', new servertools.HandlerStatic('./public', {
+  serveIndexHtmlDefault: true,
+  enableCompression: true,
+}));
+
+await server.start(3000);
+```
+
+### Proxy Handler
+
+```typescript
+import { servertools } from '@api.global/typedserver';
+
+const server = new servertools.Server({ cors: true });
+
+// Proxy requests to another server
+server.addRoute('/proxy/{*splat}', new servertools.HandlerProxy({
+  target: 'https://api.example.com',
+}));
+
+await server.start(3000);
+```
+
+## ☁️ Edge Worker (Cloudflare Workers)
+
+```typescript
+import { EdgeWorker, DomainRouter } from '@api.global/typedserver/edgeworker';
+
+const router = new DomainRouter();
+
+router.addDomainInstruction({
+  domainPattern: '*.example.com',
+  originUrl: 'https://origin.example.com',
+  cacheConfig: { maxAge: 3600 },
+});
+
+const worker = new EdgeWorker(router);
+
+// In your Cloudflare Worker entry point
+export default {
+  fetch: (request: Request, env: any, ctx: any) => worker.handleRequest(request, env, ctx),
+};
+```
+
+## 🔧 Service Worker Client
+
+```typescript
+import { ServiceWorkerClient } from '@api.global/typedserver/web_serviceworker_client';
+
+const swClient = new ServiceWorkerClient();
+
+// Register and manage service worker
+await swClient.register('/serviceworker.bundle.js');
+
+// Listen for updates
+swClient.onUpdate(() => {
+  console.log('New version available!');
+});
+```
+
+## 📋 Configuration Reference
+
+### IServerOptions
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `serveDir` | `string` | - | Directory to serve static files from |
+| `port` | `number \| string` | `3000` | Port to listen on |
+| `cors` | `boolean` | `true` | Enable CORS headers |
+| `watch` | `boolean` | `false` | Watch files for changes |
+| `injectReload` | `boolean` | `false` | Inject live reload script into HTML |
+| `enableCompression` | `boolean` | `false` | Enable response compression |
+| `preferredCompressionMethod` | `'gzip' \| 'deflate' \| 'brotli'` | - | Preferred compression algorithm |
+| `forceSsl` | `boolean` | `false` | Redirect HTTP to HTTPS |
+| `sitemap` | `boolean` | `false` | Generate sitemap at `/sitemap` |
+| `feed` | `boolean` | `false` | Generate RSS feed at `/feed` |
+| `robots` | `boolean` | `false` | Serve robots.txt |
+| `domain` | `string` | - | Domain name for sitemap/feeds |
+| `appVersion` | `string` | - | Application version string |
+| `manifest` | `object` | - | Web App Manifest configuration |
+| `publicKey` | `string` | - | SSL certificate |
+| `privateKey` | `string` | - | SSL private key |
+
+## 🏗️ Architecture
+
+```
+@api.global/typedserver
+├── /backend         - Main server exports (TypedServer, servertools)
+├── /edgeworker      - Cloudflare Workers edge computing
+├── /web_inject      - Live reload script injection
+├── /web_serviceworker - Service Worker implementation
+└── /web_serviceworker_client - Service Worker client utilities
+```
+
+## License and Legal Information
+
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [LICENSE](./LICENSE) file.
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
+
+### Company Information
+
+Task Venture Capital GmbH
+Registered at District Court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

test/test.reload.ts

@@ -1,4 +1,4 @@
-import { tap, expect } from '@push.rocks/tapbundle';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as smartpath from '@push.rocks/smartpath';
 
 import { TypedServer } from '../ts/index.js';

test/test.server.ts

@@ -1,5 +1,5 @@
 // tslint:disable-next-line:no-implicit-dependencies
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 
 // helper dependencies
 // tslint:disable-next-line:no-implicit-dependencies
@@ -48,7 +48,7 @@ tap.test('should create a valid Server', async () => {
 
 tap.test('should create a valid Route', async () => {
   testRoute = testServer.addRoute('/someroute');
-  testRoute2 = testServer.addRoute('/someroute/*');
+  testRoute2 = testServer.addRoute('/someroute/*splat');
   expect(testRoute).toBeInstanceOf(typedserver.servertools.Route);
 });
 
@@ -95,15 +95,18 @@ tap.test('should start the server allright', async () => {
 
 // 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: {
+  const smartRequestInstance = smartrequest.SmartRequest.create();
+  const response = await smartRequestInstance
+    .url('http://127.0.0.1:3000/someroute')
+    .headers({
       'X-Forwarded-Proto': 'https',
-    },
-    requestBody: {
+    })
+    .json({
       someprop: 'hi',
-    },
-  });
-  console.log(response.body);
+    })
+    .post();
+  const responseBody = await response.text();
+  console.log(responseBody);
 });
 
 tap.test('should get a file from disk', async () => {
@@ -119,7 +122,7 @@ tap.test('should answer a preflight request', async () => {
   console.log(response.headers);
 });
 
-tap.test('should exposer a sitemap', async () => {
+tap.test('should expose a sitemap', async () => {
   const response = await fetch('http://127.0.0.1:3000/sitemap');
   console.log(await response.text());
 });

ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@api.global/typedserver',
-  version: '3.0.7',
-  description: 'easy serving of static files'
+  version: '4.1.0',
+  description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }

ts/classes.typedserver.ts

@@ -0,0 +1,606 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import { DevToolsController } from './controllers/controller.devtools.js';
+import { TypedRequestController } from './controllers/controller.typedrequest.js';
+import { BuiltInRoutesController } from './controllers/controller.builtin.js';
+
+export interface IServerOptions {
+  /**
+   * serve a particular directory
+   */
+  serveDir?: string;
+
+  /**
+   * inject a reload script that takes care of live reloading
+   */
+  injectReload?: boolean;
+
+  /**
+   * watch the serve directory?
+   */
+  watch?: boolean;
+
+  cors: boolean;
+
+  /**
+   * a default answer given in case there is no other handler.
+   */
+  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
+   */
+  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 type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'ALL';
+
+export interface IRouteHandler {
+  (request: Request): Promise<Response | null>;
+}
+
+export interface IRegisteredRoute {
+  pattern: string;
+  regex: RegExp;
+  paramNames: string[];
+  method: THttpMethod;
+  handler: IRouteHandler;
+}
+
+export class TypedServer {
+  // instance
+  public options: IServerOptions;
+  public smartServe: plugins.smartserve.SmartServe;
+  public smartwatchInstance: plugins.smartwatch.Smartwatch;
+  public serveDirHashSubject = new plugins.smartrx.rxjs.ReplaySubject<string>(1);
+  public serveHash: string = '000000';
+  public typedsocket: plugins.typedsocket.TypedSocket;
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  // Sitemap helper
+  private sitemapHelper: SitemapHelper;
+  private smartmanifestInstance: plugins.smartmanifest.SmartManifest;
+
+  // Decorated controllers
+  private devToolsController: DevToolsController;
+  private typedRequestController: TypedRequestController;
+  private builtInRoutesController: BuiltInRoutesController;
+
+  // File server for static files
+  private fileServer: plugins.smartserve.FileServer;
+
+  // Custom route handlers (for addRoute API)
+  private customRoutes: IRegisteredRoute[] = [];
+
+  public lastReload: number = Date.now();
+  public ended = false;
+
+  constructor(optionsArg: IServerOptions) {
+    const standardOptions: IServerOptions = {
+      port: 3000,
+      injectReload: false,
+      serveDir: null,
+      watch: false,
+      cors: true,
+    };
+    this.options = {
+      ...standardOptions,
+      ...optionsArg,
+    };
+  }
+
+  /**
+   * Access sitemap URLs (for adding/replacing)
+   */
+  public get sitemap() {
+    return this.sitemapHelper;
+  }
+
+  /**
+   * Add a custom route handler
+   * Supports Express-style path patterns like '/path/:param' and '/path/*splat'
+   * @param path - The route path pattern
+   * @param method - HTTP method (GET, POST, PUT, DELETE, PATCH, ALL)
+   * @param handler - Async function that receives Request and returns Response or null
+   */
+  public addRoute(path: string, method: THttpMethod, handler: IRouteHandler): void {
+    // Convert Express-style path to regex
+    const paramNames: string[] = [];
+    let regexPattern = path
+      // Handle named parameters :param
+      .replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
+        paramNames.push(paramName);
+        return '([^/]+)';
+      })
+      // Handle wildcard *splat (matches everything including slashes)
+      .replace(/\*([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
+        paramNames.push(paramName);
+        return '(.*)';
+      });
+
+    // Ensure exact match
+    regexPattern = `^${regexPattern}$`;
+
+    this.customRoutes.push({
+      pattern: path,
+      regex: new RegExp(regexPattern),
+      paramNames,
+      method,
+      handler,
+    });
+  }
+
+  /**
+   * Parse route parameters from a path using a registered route
+   */
+  private parseRouteParams(
+    route: IRegisteredRoute,
+    pathname: string
+  ): Record<string, string> | null {
+    const match = pathname.match(route.regex);
+    if (!match) return null;
+
+    const params: Record<string, string> = {};
+    route.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1];
+    });
+    return params;
+  }
+
+  /**
+   * inits and starts the server
+   */
+  public async start() {
+    // Validate essential configuration before starting
+    if (this.options.injectReload && !this.options.serveDir) {
+      throw new Error(
+        'You set to inject the reload script without a serve dir. This is not supported at the moment.'
+      );
+    }
+
+    const port =
+      typeof this.options.port === 'string'
+        ? parseInt(this.options.port, 10)
+        : this.options.port || 3000;
+
+    // Initialize optional helpers
+    if (this.options.sitemap) {
+      this.sitemapHelper = new SitemapHelper(this.options.domain);
+    }
+    if (this.options.manifest) {
+      this.smartmanifestInstance = new plugins.smartmanifest.SmartManifest(this.options.manifest);
+    }
+
+    // Initialize file server for static files
+    if (this.options.serveDir) {
+      this.fileServer = new plugins.smartserve.FileServer({
+        root: this.options.serveDir,
+        index: ['index.html'],
+        etag: true,
+      });
+    }
+
+    // Initialize decorated controllers
+    this.devToolsController = new DevToolsController({
+      getLastReload: () => this.lastReload,
+      getEnded: () => this.ended,
+    });
+
+    this.typedRequestController = new TypedRequestController(this.typedrouter);
+
+    this.builtInRoutesController = new BuiltInRoutesController({
+      domain: this.options.domain,
+      robots: this.options.robots,
+      manifest: this.smartmanifestInstance,
+      sitemap: this.options.sitemap,
+      feed: this.options.feed,
+      appVersion: this.options.appVersion,
+      feedMetadata: this.options.feedMetadata,
+      articleGetterFunction: this.options.articleGetterFunction,
+      blockWaybackMachine: this.options.blockWaybackMachine,
+      getSitemapUrls: () => this.sitemapHelper?.urls || [],
+    });
+
+    // Register controllers with SmartServe's ControllerRegistry
+    plugins.smartserve.ControllerRegistry.registerInstance(this.devToolsController);
+    plugins.smartserve.ControllerRegistry.registerInstance(this.typedRequestController);
+    plugins.smartserve.ControllerRegistry.registerInstance(this.builtInRoutesController);
+
+    // Build SmartServe options
+    const smartServeOptions: plugins.smartserve.ISmartServeOptions = {
+      port,
+      hostname: '0.0.0.0',
+      tls:
+        this.options.privateKey && this.options.publicKey
+          ? {
+              key: this.options.privateKey,
+              cert: this.options.publicKey,
+            }
+          : undefined,
+      websocket: {
+        typedRouter: this.typedrouter,
+        onConnectionOpen: (peer) => {
+          peer.tags.add('typedserver_frontend');
+          console.log(`WebSocket connected: ${peer.id}`);
+        },
+        onConnectionClose: (peer) => {
+          console.log(`WebSocket disconnected: ${peer.id}`);
+        },
+      },
+    };
+
+    this.smartServe = new plugins.smartserve.SmartServe(smartServeOptions);
+
+    // Set up custom request handler that integrates with ControllerRegistry
+    this.smartServe.setHandler(async (request: Request): Promise<Response> => {
+      return this.handleRequest(request);
+    });
+
+    // Setup file watching
+    if (this.options.watch && this.options.serveDir) {
+      try {
+        this.smartwatchInstance = new plugins.smartwatch.Smartwatch([this.options.serveDir]);
+        await this.smartwatchInstance.start();
+        (await this.smartwatchInstance.getObservableFor('change')).subscribe(async () => {
+          await this.createServeDirHash();
+          this.reload();
+        });
+        await this.createServeDirHash();
+      } catch (error) {
+        console.error('Failed to initialize file watching:', error);
+      }
+    }
+
+    // Start the server
+    await this.smartServe.start();
+    console.log(`TypedServer listening on port ${port}`);
+
+    // Setup TypedSocket using SmartServe integration
+    try {
+      this.typedsocket = plugins.typedsocket.TypedSocket.fromSmartServe(
+        this.smartServe,
+        this.typedrouter
+      );
+
+      // Setup typedrouter handlers
+      this.typedrouter.addTypedHandler<interfaces.IReq_GetLatestServerChangeTime>(
+        new plugins.typedrequest.TypedHandler('getLatestServerChangeTime', async () => {
+          return {
+            time: this.lastReload,
+          };
+        })
+      );
+    } catch (error) {
+      console.error('Failed to initialize TypedSocket:', error);
+    }
+  }
+
+  /**
+   * Create an IRequestContext from a Request
+   */
+  private async createContext(
+    request: Request,
+    params: Record<string, string>
+  ): Promise<plugins.smartserve.IRequestContext> {
+    const url = new URL(request.url);
+    const method = request.method.toUpperCase() as THttpMethod;
+
+    // Parse query params
+    const query: Record<string, string> = {};
+    url.searchParams.forEach((value, key) => {
+      query[key] = value;
+    });
+
+    // Parse body
+    let body: unknown = undefined;
+    const contentType = request.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+      try {
+        body = await request.clone().json();
+      } catch {
+        body = {};
+      }
+    }
+
+    return {
+      request,
+      body,
+      params,
+      query,
+      headers: request.headers,
+      path: url.pathname,
+      method,
+      url,
+      runtime: 'node' as const,
+      state: {},
+    };
+  }
+
+  /**
+   * Main request handler - routes to appropriate sub-handlers
+   */
+  private async handleRequest(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const method = request.method.toUpperCase() as THttpMethod;
+
+    // First, try to match via ControllerRegistry (decorated routes)
+    const match = plugins.smartserve.ControllerRegistry.matchRoute(path, method);
+    if (match) {
+      try {
+        const context = await this.createContext(request, match.params);
+        const result = await match.route.handler(context);
+
+        // Handle Response or convert to Response
+        if (result instanceof Response) {
+          return result;
+        }
+        return new Response(JSON.stringify(result), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      } catch (error) {
+        if (error instanceof plugins.smartserve.RouteNotFoundError) {
+          // Route explicitly threw "not found", continue to other handlers
+        } else {
+          console.error('Controller error:', error);
+          return new Response('Internal Server Error', { status: 500 });
+        }
+      }
+    }
+
+    // Custom routes (registered via addRoute)
+    for (const route of this.customRoutes) {
+      if (route.method === 'ALL' || route.method === method) {
+        const params = this.parseRouteParams(route, path);
+        if (params !== null) {
+          (request as any).params = params;
+          const response = await route.handler(request);
+          if (response) return response;
+        }
+      }
+    }
+
+    // HTML injection for reload (if enabled)
+    if (this.options.injectReload && this.options.serveDir) {
+      const response = await this.handleHtmlWithInjection(request);
+      if (response) return response;
+    }
+
+    // Try static file serving
+    if (this.fileServer && (method === 'GET' || method === 'HEAD')) {
+      try {
+        const staticResponse = await this.fileServer.serve(request);
+        if (staticResponse) {
+          return staticResponse;
+        }
+      } catch (error) {
+        // Fall through to 404
+      }
+    }
+
+    // Default answer for root
+    if (path === '/' && method === 'GET' && this.options.defaultAnswer) {
+      const html = await this.options.defaultAnswer();
+      return new Response(html, {
+        status: 200,
+        headers: { 'Content-Type': 'text/html' },
+      });
+    }
+
+    // Not found
+    return new Response('Not Found', { status: 404 });
+  }
+
+  /**
+   * Handle HTML files with reload script injection
+   */
+  private async handleHtmlWithInjection(request: Request): Promise<Response | null> {
+    const url = new URL(request.url);
+    const requestPath = url.pathname;
+
+    // Check if this is a request for an HTML file or root
+    if (requestPath === '/' || requestPath.endsWith('.html') || !requestPath.includes('.')) {
+      try {
+        let filePath = requestPath === '/' ? 'index.html' : requestPath.slice(1);
+        if (!filePath.endsWith('.html') && !filePath.includes('.')) {
+          filePath = plugins.path.join(filePath, 'index.html');
+        }
+
+        const fullPath = plugins.path.join(this.options.serveDir, filePath);
+
+        // Security check
+        if (!fullPath.startsWith(this.options.serveDir)) {
+          return new Response('Forbidden', { status: 403 });
+        }
+
+        let fileContent = (await plugins.fsInstance
+          .file(fullPath)
+          .encoding('utf8')
+          .read()) as string;
+
+        // Inject reload script
+        if (fileContent.includes('<head>')) {
+          const injection = `<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 -->
+              `;
+          fileContent = fileContent.replace('<head>', injection);
+          console.log('injected typedserver script.');
+        }
+
+        return new Response(fileContent, {
+          status: 200,
+          headers: {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Cache-Control': 'no-cache, no-store, must-revalidate',
+            Pragma: 'no-cache',
+            Expires: '0',
+            appHash: this.serveHash,
+          },
+        });
+      } catch (error) {
+        // Fall through to default handling
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * reloads the page
+   */
+  public async reload() {
+    this.lastReload = Date.now();
+    if (!this.typedsocket) {
+      console.warn('TypedSocket not initialized, skipping client notifications');
+      return;
+    }
+
+    try {
+      const connections = await this.typedsocket.findAllTargetConnectionsByTag(
+        'typedserver_frontend'
+      );
+      for (const connection of connections) {
+        const pushTime =
+          this.typedsocket.createTypedRequest<interfaces.IReq_PushLatestServerChangeTime>(
+            'pushLatestServerChangeTime',
+            connection
+          );
+        pushTime.fire({
+          time: this.lastReload,
+        });
+      }
+    } catch (error) {
+      console.error('Failed to notify clients about reload:', error);
+    }
+  }
+
+  /**
+   * Stops the server and cleans up resources
+   */
+  public async stop(): Promise<void> {
+    this.ended = true;
+
+    const stopWithErrorHandling = async (
+      stopFn: () => Promise<unknown>,
+      componentName: string
+    ): Promise<void> => {
+      try {
+        await stopFn();
+      } catch (err) {
+        console.error(`Error stopping ${componentName}:`, err);
+      }
+    };
+
+    const tasks: Promise<void>[] = [];
+
+    // Stop SmartServe
+    if (this.smartServe) {
+      tasks.push(stopWithErrorHandling(() => this.smartServe.stop(), 'SmartServe'));
+    }
+
+    // Stop TypedSocket (in SmartServe mode, this is a no-op but good for cleanup)
+    if (this.typedsocket) {
+      tasks.push(stopWithErrorHandling(() => this.typedsocket.stop(), 'TypedSocket'));
+    }
+
+    // Stop file watcher
+    if (this.smartwatchInstance) {
+      tasks.push(stopWithErrorHandling(() => this.smartwatchInstance.stop(), 'file watcher'));
+    }
+
+    await Promise.all(tasks);
+  }
+
+  /**
+   * Calculates a hash of the served directory for cache busting
+   */
+  public async createServeDirHash() {
+    try {
+      const serveDirHash = await plugins.fsInstance
+        .directory(this.options.serveDir)
+        .recursive()
+        .treeHash();
+      this.serveHash = serveDirHash.slice(0, 12);
+      console.log('Current ServeDir hash: ' + this.serveHash);
+      this.serveDirHashSubject.next(this.serveHash);
+    } catch (error) {
+      console.error('Failed to create serve directory hash:', error);
+      const fallbackHash = Date.now().toString(16).slice(-6);
+      this.serveHash = fallbackHash;
+      console.log('Using fallback hash: ' + fallbackHash);
+      this.serveDirHashSubject.next(fallbackHash);
+    }
+  }
+}
+
+// ============================================================================
+// Helper Classes
+// ============================================================================
+
+/**
+ * Sitemap helper class
+ */
+class SitemapHelper {
+  private smartSitemap = new plugins.smartsitemap.SmartSitemap();
+  public urls: plugins.smartsitemap.IUrlInfo[] = [];
+
+  constructor(domain?: string) {
+    if (domain) {
+      this.urls.push({
+        url: `https://${domain}/`,
+        timestamp: Date.now(),
+        frequency: 'daily',
+      });
+    }
+  }
+
+  async createSitemap(): Promise<string> {
+    return this.smartSitemap.createSitemapFromUrlInfoArray(this.urls);
+  }
+
+  async createSitemapNews(articles: plugins.tsclass.content.IArticle[]): Promise<string> {
+    return this.smartSitemap.createSitemapNewsFromArticleArray(articles);
+  }
+
+  replaceUrls(urlsArg: plugins.smartsitemap.IUrlInfo[]) {
+    this.urls = urlsArg;
+  }
+
+  addUrls(urlsArg: plugins.smartsitemap.IUrlInfo[]) {
+    this.urls = this.urls.concat(urlsArg);
+  }
+}

ts/controllers/controller.builtin.ts

@@ -0,0 +1,125 @@
+import * as plugins from '../plugins.js';
+
+/**
+ * Built-in routes controller for TypedServer
+ * Handles robots.txt, manifest.json, sitemap, feed, appversion
+ */
+@plugins.smartserve.Route('')
+export class BuiltInRoutesController {
+  private options: {
+    domain?: string;
+    robots?: boolean;
+    manifest?: plugins.smartmanifest.SmartManifest;
+    sitemap?: boolean;
+    feed?: boolean;
+    appVersion?: string;
+    feedMetadata?: plugins.smartfeed.IFeedOptions;
+    articleGetterFunction?: () => Promise<plugins.tsclass.content.IArticle[]>;
+    blockWaybackMachine?: boolean;
+    getSitemapUrls: () => plugins.smartsitemap.IUrlInfo[];
+  };
+
+  constructor(options: typeof BuiltInRoutesController.prototype.options) {
+    this.options = options;
+  }
+
+  @plugins.smartserve.Get('/robots.txt')
+  async getRobots(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.robots || !this.options.domain) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const robotsContent = [
+      'User-agent: *',
+      'Allow: /',
+      `Sitemap: https://${this.options.domain}/sitemap`,
+    ];
+
+    if (this.options.blockWaybackMachine) {
+      robotsContent.push('', 'User-agent: ia_archiver', 'Disallow: /');
+    }
+
+    return new Response(robotsContent.join('\n'), {
+      status: 200,
+      headers: { 'Content-Type': 'text/plain' },
+    });
+  }
+
+  @plugins.smartserve.Get('/manifest.json')
+  async getManifest(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.manifest) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    return new Response(this.options.manifest.jsonString(), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sitemap')
+  async getSitemap(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.sitemap || !this.options.domain) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const smartsitemap = new plugins.smartsitemap.SmartSitemap();
+    const urls = this.options.getSitemapUrls();
+    const sitemapXml = await smartsitemap.createSitemapFromUrlInfoArray(urls);
+
+    return new Response(sitemapXml, {
+      status: 200,
+      headers: { 'Content-Type': 'application/xml' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sitemap-news')
+  async getSitemapNews(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.sitemap || !this.options.domain || !this.options.articleGetterFunction) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const smartsitemap = new plugins.smartsitemap.SmartSitemap();
+    const articles = await this.options.articleGetterFunction();
+    const sitemapNewsXml = await smartsitemap.createSitemapNewsFromArticleArray(articles);
+
+    return new Response(sitemapNewsXml, {
+      status: 200,
+      headers: { 'Content-Type': 'application/xml' },
+    });
+  }
+
+  @plugins.smartserve.Get('/feed')
+  async getFeed(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.feed || !this.options.feedMetadata) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const smartfeed = new plugins.smartfeed.Smartfeed();
+    const articles = this.options.articleGetterFunction
+      ? await this.options.articleGetterFunction()
+      : [];
+
+    const feedXml = await smartfeed.createFeedFromArticleArray(
+      this.options.feedMetadata,
+      articles
+    );
+
+    return new Response(feedXml, {
+      status: 200,
+      headers: { 'Content-Type': 'application/atom+xml' },
+    });
+  }
+
+  @plugins.smartserve.Get('/appversion')
+  async getAppVersion(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.appVersion) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    return new Response(this.options.appVersion, {
+      status: 200,
+      headers: { 'Content-Type': 'text/plain' },
+    });
+  }
+}

ts/controllers/controller.devtools.ts

@@ -0,0 +1,53 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+
+/**
+ * DevTools controller for TypedServer
+ * Handles /typedserver/devtools and /typedserver/reloadcheck endpoints
+ */
+@plugins.smartserve.Route('/typedserver')
+export class DevToolsController {
+  private getLastReload: () => number;
+  private getEnded: () => boolean;
+
+  constructor(options: { getLastReload: () => number; getEnded: () => boolean }) {
+    this.getLastReload = options.getLastReload;
+    this.getEnded = options.getEnded;
+  }
+
+  @plugins.smartserve.Get('/devtools')
+  async getDevtools(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    const devtoolsContent = (await plugins.fsInstance
+      .file(paths.injectBundlePath)
+      .encoding('utf8')
+      .read()) as string;
+
+    return new Response(devtoolsContent, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/javascript',
+      },
+    });
+  }
+
+  @plugins.smartserve.Get('/reloadcheck')
+  async reloadCheck(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    console.log('got request for reloadcheck');
+
+    if (this.getEnded()) {
+      return new Response('end', {
+        status: 200,
+        headers: {
+          'Content-Type': 'text/plain',
+        },
+      });
+    }
+
+    return new Response(this.getLastReload().toString(), {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    });
+  }
+}

ts/controllers/controller.typedrequest.ts

@@ -0,0 +1,34 @@
+import * as plugins from '../plugins.js';
+
+/**
+ * TypedRequest controller for type-safe RPC endpoint
+ */
+@plugins.smartserve.Route('/typedrequest')
+export class TypedRequestController {
+  private typedRouter: plugins.typedrequest.TypedRouter;
+
+  constructor(typedRouter: plugins.typedrequest.TypedRouter) {
+    this.typedRouter = typedRouter;
+  }
+
+  @plugins.smartserve.Post('/')
+  async handleTypedRequest(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    try {
+      const response = await this.typedRouter.routeAndAddResponse(ctx.body as plugins.typedrequestInterfaces.ITypedRequest);
+
+      return new Response(plugins.smartjson.stringify(response), {
+        status: 200,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    } catch (error) {
+      return new Response(JSON.stringify({ error: 'Invalid request' }), {
+        status: 400,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    }
+  }
+}

ts/controllers/index.ts

@@ -0,0 +1,3 @@
+export * from './controller.devtools.js';
+export * from './controller.typedrequest.js';
+export * from './controller.builtin.js';

ts/index.ts

@@ -1,10 +1,15 @@
-import * as plugins from './typedserver.plugins.js';
+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;
+export * from './classes.typedserver.js';
+
+// Type helpers - using native Web API Request/Response types
+// Native Request and Response are available in Node.js 18+ and all modern browsers
+// Legacy Express types are available via servertools for backward compatibility
+
+// lets export utilityservers
+import * as utilityservers from './utilityservers/index.js';
+export { utilityservers };

ts/infohtml/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@losslessone_private/lole-infohtml',
+  version: '1.0.39',
+  description: 'html for displaying infos at lossless'
+}

ts/infohtml/index.ts

@@ -0,0 +1,44 @@
+import * as plugins from './infohtml.plugins.js';
+
+import { simpleInfo } from './template.js';
+
+export interface IHtmlInfoOptions {
+  text: string;
+  heading?: string;
+  title?: string;
+  sentryMessage?: string;
+  sentryDsn?: string;
+  redirectTo?: string;
+}
+
+export class InfoHtml {
+  // STATIC
+  public static async fromSimpleText(textArg: string) {
+    const infohtmlInstance = new InfoHtml({
+      text: textArg,
+      heading: null,
+    });
+    await infohtmlInstance.init();
+    return infohtmlInstance;
+  }
+
+  public static async fromOptions(optionsArg: IHtmlInfoOptions) {
+    const infohtmlInstance = new InfoHtml(optionsArg);
+    await infohtmlInstance.init();
+    return infohtmlInstance;
+  }
+
+  // INSTANCE
+  public options: IHtmlInfoOptions;
+  public smartntmlInstance: plugins.smartntml.Smartntml;
+  public htmlString: string;
+  constructor(optionsArg: IHtmlInfoOptions) {
+    this.options = optionsArg;
+  }
+
+  public async init() {
+    this.smartntmlInstance = new plugins.smartntml.Smartntml();
+    this.htmlString = await simpleInfo(this.smartntmlInstance, this.options);
+    return this.htmlString;
+  }
+}

ts/infohtml/infohtml.plugins.ts

@@ -0,0 +1,3 @@
+import * as smartntml from '@push.rocks/smartntml';
+
+export { smartntml };

ts/infohtml/template.ts

@@ -0,0 +1,132 @@
+import * as plugins from './infohtml.plugins.js';
+import { type IHtmlInfoOptions } from './index.js';
+
+export const simpleInfo = async (
+  smartntmlInstanceArg: plugins.smartntml.Smartntml,
+  optionsArg: IHtmlInfoOptions
+) => {
+  const html = plugins.smartntml.deesElement.html;
+  const htmlTemplate = await plugins.smartntml.deesElement.html`
+    <html lang="en">
+      <head>
+        <title>${optionsArg.title}</title>
+        <script>
+          setTimeout(() => {
+            const redirectUrl = '${optionsArg.redirectTo}';
+            if (redirectUrl) {
+              window.location = redirectUrl;
+            }
+          }, 5000);
+        </script>
+        <style>
+          body {
+            margin: 0px;
+            background: #000000;
+            font-family: 'Roboto Mono', monospace;
+            min-height: 100vh;
+            min-width: 100vw;
+            border: 1px solid #e4002b;
+          }
+
+          * {
+            box-sizing: border-box;
+          }
+
+          .logo {
+            width: 150px;
+            padding-top: 70px;
+            margin: 0px auto 30px auto;
+          }
+
+          .content {
+            text-align: center;
+            max-width: 800px;
+            margin: auto;
+          }
+
+          .content .maintext {
+            margin: 10px;
+            color: #ffffff;
+            background: #333;
+            display: block;
+            border-radius: 3px;
+            box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.3);
+            padding: 20px;
+          }
+
+          .content .maintext h1 {
+            margin: 0px;
+          }
+
+          .content .addontext {
+            margin: 10px;
+            color: #ffffff;
+            background: #222;
+            display: block;
+            padding: 10px 15px;
+            border-radius: 3px;
+            box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.3);
+            padding: 10px;
+          }
+
+          .content .text h1 {
+            margin: 0px;
+            font-weight: 100;
+            font-size: 40px;
+          }
+
+          .content .text ul {
+            text-align: left;
+          }
+
+          a {
+            color: #ffffff;
+          }
+
+          .legal {
+            color: #fff;
+            position: fixed;
+            bottom: 0px;
+            width: 100vw;
+            text-align: center;
+            padding: 10px;
+          }
+        </style>
+        <meta
+          name="viewport"
+          content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width, height=device-height, target-densitydpi=device-dpi"
+        />
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+      </head>
+      <body>
+        <div class="content">
+          ${(() => {
+            const returnArray: plugins.smartntml.deesElement.TemplateResult[] = [];
+            if (optionsArg.heading) {
+              returnArray.push(html`
+                <div class="maintext">
+                  <h1>${optionsArg.heading}</h1>
+                  ${optionsArg.text}
+                </div>
+              `);
+            } else {
+              returnArray.push(html` <div class="maintext">${optionsArg.text}</div> `);
+            }
+            if (optionsArg.redirectTo) {
+              returnArray.push(
+                html`<div class="addontext">
+                  We will redirect you to ${optionsArg.redirectTo} in a few seconds.
+                </div>`
+              );
+            }
+            return returnArray;
+          })()}
+        </div>
+        <div class="legal">
+          <a href="https://foss.global">learn more about foss.global</a> / &copy 2014-${new Date().getFullYear()} Task Venture Capital GmbH
+        </div>
+      </body>
+    </html>
+  `;
+  return smartntmlInstanceArg.renderTemplateResult(htmlTemplate);
+};

ts/paths.ts

@@ -0,0 +1,11 @@
+import * as plugins from './plugins.js';
+
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);
+
+export const injectBundleDir = plugins.path.join(packageDir, './dist_ts_web_inject');
+export const injectBundlePath = plugins.path.join(injectBundleDir, './bundle.js');
+
+export const serviceworkerBundleDir = plugins.path.join(packageDir, './dist_ts_web_serviceworker');

ts/plugins.ts

@@ -3,8 +3,9 @@ import * as http from 'http';
 import * as https from 'https';
 import * as net from 'net';
 import * as path from 'path';
+import * as zlib from 'zlib';
 
-export { http, https, net, path };
+export { http, https, net, path, zlib };
 
 // @tsclass scope
 import * as tsclass from '@tsclass/tsclass';
@@ -20,10 +21,12 @@ export { typedrequest, typedrequestInterfaces, typedsocket };
 
 // @pushrocks scope
 import * as lik from '@push.rocks/lik';
-import * as smartchok from '@push.rocks/smartchok';
+import * as smartwatch from '@push.rocks/smartwatch';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartfeed from '@push.rocks/smartfeed';
 import * as smartfile from '@push.rocks/smartfile';
+import * as smartfs from '@push.rocks/smartfs';
+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';
@@ -32,14 +35,17 @@ 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,
+  smartwatch,
   smartdelay,
   smartfeed,
   smartfile,
+  smartfs,
+  smartjson,
   smartmanifest,
   smartmime,
   smartopen,
@@ -47,15 +53,24 @@ export {
   smartpromise,
   smartrequest,
   smartsitemap,
+  smartstream,
   smarttime,
   smartrx,
 };
 
-// express
+// Create a ready-to-use smartfs instance with Node.js provider
+export const fsInstance = new smartfs.SmartFs(new smartfs.SmartFsProviderNode());
+
+// @push.rocks/smartserve
+import * as smartserve from '@push.rocks/smartserve';
+
+export { smartserve };
+
+// Legacy Express dependencies - kept for backward compatibility with deprecated servertools
+// These will be removed in the next major version
+import express from '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 };
+export { express, bodyParser, cors, expressForceSsl };

ts/servertools/classes.compressor.ts

@@ -0,0 +1,131 @@
+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();
+        return compressionStream;
+      case 'br':
+        compressionStream = plugins.zlib.createBrotliCompress({
+          chunkSize: 16 * 1024,
+          params: {
+            
+          },
+        });
+        return compressionStream;
+      case 'deflate':
+        compressionStream = plugins.zlib.createDeflate();
+        return compressionStream;
+      default:
+        compressionStream = plugins.smartstream.createPassThrough();
+        return compressionStream;
+    }
+  }
+}

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;

ts/servertools/classes.handler.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../typedserver.plugins.js';
+import * as plugins from '../plugins.js';
 import { type Request, type Response } from 'express';
 
 export interface IHandlerFunction {

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 {
   /**
@@ -16,21 +16,67 @@ export class HandlerProxy extends Handler {
     }
   ) {
     super('ALL', async (req, res) => {
-      const relativeRequestPath = req.path.slice(req.route.path.length - 1);
+      // Extract the path using Express 5's params or fallback methods
+      let relativeRequestPath: string;
+      if (req.params && req.params.splat !== undefined) {
+        // Express 5 wildcard route (/*splat or /{*splat})
+        // Handle array values - join them if array, otherwise use as-is
+        relativeRequestPath = Array.isArray(req.params.splat) ? req.params.splat.join('/') : String(req.params.splat || '');
+      } else if (req.params && req.params[0] !== undefined) {
+        // Numbered parameter fallback
+        relativeRequestPath = Array.isArray(req.params[0]) ? req.params[0].join('/') : String(req.params[0] || '');
+      } else if (req.baseUrl) {
+        // If there's a baseUrl, remove it from the path
+        relativeRequestPath = req.path.slice(req.baseUrl.length);
+      } else if (req.route && req.route.path === '/') {
+        // Root route - use full path minus leading slash
+        relativeRequestPath = req.path.slice(1);
+      } else {
+        // Fallback to the original slicing logic for compatibility
+        relativeRequestPath = req.path.slice(req.route.path.length - 1);
+      }
+      
+      // Ensure relativeRequestPath is a string and has no leading slash
+      relativeRequestPath = String(relativeRequestPath || '');
+      if (relativeRequestPath.startsWith('/')) {
+        relativeRequestPath = relativeRequestPath.slice(1);
+      }
       const proxyRequestUrl = remoteMountPointArg + relativeRequestPath;
       console.log(`proxy ${req.path} to ${proxyRequestUrl}`);
-      let proxiedResponse: plugins.smartrequest.IExtendedIncomingMessage;
+      let proxiedResponse: plugins.smartrequest.ICoreResponse;
       try {
-        proxiedResponse = await plugins.smartrequest.request(proxyRequestUrl, {
-          method: req.method,
-          autoJsonParse: false,
-        });
+        const smartRequest = plugins.smartrequest.SmartRequest.create()
+          .url(proxyRequestUrl);
+        
+        // Execute request based on method
+        switch (req.method.toUpperCase()) {
+          case 'GET':
+            proxiedResponse = await smartRequest.get();
+            break;
+          case 'POST':
+            proxiedResponse = await smartRequest.post();
+            break;
+          case 'PUT':
+            proxiedResponse = await smartRequest.put();
+            break;
+          case 'DELETE':
+            proxiedResponse = await smartRequest.delete();
+            break;
+          case 'PATCH':
+            proxiedResponse = await smartRequest.patch();
+            break;
+          default:
+            // For other methods, default to GET
+            proxiedResponse = await smartRequest.get();
+            break;
+        }
       } catch {
         res.end('failed to fullfill request');
         return;
       }
-      for (const header of Object.keys(proxiedResponse.headers)) {
-        res.set(header, proxiedResponse.headers[header] as string);
+      const headers = proxiedResponse.headers;
+      for (const header of Object.keys(headers)) {
+        res.set(header, headers[header] as string);
       }
 
       // set additional headers
@@ -40,11 +86,20 @@ export class HandlerProxy extends Handler {
         }
       }
 
-      let responseToSend: string = proxiedResponse.body;
-      if (typeof responseToSend !== 'string') {
-        console.log(proxyRequestUrl);
-        console.log(responseToSend);
-        throw new Error(`Proxied response is not a string, but ${typeof responseToSend}`);
+      // Get response body as buffer
+      let responseToSend: Buffer;
+      try {
+        const arrayBuffer = await proxiedResponse.arrayBuffer();
+        responseToSend = Buffer.from(arrayBuffer);
+      } catch {
+        // If we can't get arrayBuffer, try text
+        try {
+          const text = await proxiedResponse.text();
+          responseToSend = Buffer.from(text);
+        } catch {
+          // Provide a default empty buffer if body cannot be read
+          responseToSend = Buffer.from('');
+        }
       }
 
       if (optionsArg && optionsArg.responseModifier) {
@@ -74,4 +129,4 @@ export class HandlerProxy extends Handler {
       res.end();
     });
   }
-}
+}

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) => {
@@ -32,7 +36,31 @@ export class HandlerStatic extends Handler {
       }
 
       // lets compute some paths
-      let filePath: string = requestPath.slice(req.route.path.length - 1); // lets slice of the root
+      // Extract the path using Express 5's params or fallback methods
+      let filePath: string;
+      if (req.params && req.params.splat !== undefined) {
+        // Express 5 wildcard route (/*splat or /{*splat})
+        // Handle array values - join them if array, otherwise use as-is
+        filePath = Array.isArray(req.params.splat) ? req.params.splat.join('/') : String(req.params.splat || '');
+      } else if (req.params && req.params[0] !== undefined) {
+        // Numbered parameter fallback
+        filePath = Array.isArray(req.params[0]) ? req.params[0].join('/') : String(req.params[0] || '');
+      } else if (req.baseUrl) {
+        // If there's a baseUrl, remove it from the path
+        filePath = requestPath.slice(req.baseUrl.length);
+      } else if (req.route && req.route.path === '/') {
+        // Root route - use full path minus leading slash
+        filePath = requestPath.slice(1);
+      } else {
+        // Fallback to the original slicing logic for compatibility
+        filePath = requestPath.slice(req.route.path.length - 1);
+      }
+      
+      // Ensure filePath is a string and has no leading slash
+      filePath = String(filePath || '');
+      if (filePath.startsWith('/')) {
+        filePath = filePath.slice(1);
+      }
       if (requestPath === '') {
         console.log('replaced root with index.html');
         filePath = 'index.html';
@@ -62,11 +90,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 = await plugins.fsInstance.file(joinedPath).read() as Buffer;
         usedPath = joinedPath;
       } catch (err) {
         // try serving index.html instead
@@ -75,8 +101,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 = await plugins.fsInstance.file(defaultPath).read() as Buffer;
             usedPath = defaultPath;
           } catch (err) {
             res.writeHead(500);
@@ -99,7 +124,7 @@ export class HandlerStatic extends Handler {
         const modifiedResponse = await optionsArg.responseModifier({
           headers: res.getHeaders(),
           path: usedPath,
-          responseContent: fileString,
+          responseContent: fileBuffer,
           travelData,
         });
 
@@ -115,11 +140,28 @@ 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);
+      } else {
+        res.write(fileBuffer);
+      }
       res.end();
     });
   }

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();
     });
   }
 }

ts/servertools/classes.route.ts

@@ -1,4 +1,4 @@
-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';
 
@@ -6,7 +6,13 @@ import { type IRoute as IExpressRoute } from 'express';
 
 export class Route {
   public routeString: string;
+
+  /**
+   * an object map of handlers
+   * Why multiple? Because GET, POST, PUT, DELETE, etc. can all have different handlers
+   */
   public handlerObjectMap = new plugins.lik.ObjectMap<Handler>();
+  
   public expressMiddlewareObjectMap = new plugins.lik.ObjectMap<any>();
   public expressRoute: IExpressRoute; // will be set to server route on server start
   constructor(ServerArg: Server, routeStringArg: string) {

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';
@@ -9,7 +9,7 @@ import { setupRobots } from './tools.robots.js';
 import { setupManifest } from './tools.manifest.js';
 import { Sitemap } from './classes.sitemap.js';
 import { Feed } from './classes.feed.js';
-import { type IServerOptions } from '../typedserver.classes.typedserver.js';
+import { type IServerOptions } from '../classes.typedserver.js';
 export type TServerStatus = 'initiated' | 'running' | 'stopped';
 
 /**
@@ -77,6 +77,11 @@ export class Server {
     return route;
   }
 
+  /**
+   * starts the server and sets up the routes
+   * @param portArg
+   * @param doListen
+   */
   public async start(portArg: number | string = this.options.port, doListen = true) {
     const done = plugins.smartpromise.defer();
 
@@ -127,7 +132,7 @@ export class Server {
       });
 
       this.expressAppInstance.use(cors);
-      this.expressAppInstance.options('/*', cors);
+      this.expressAppInstance.options('/{*splat}', cors);
     }
 
     this.expressAppInstance.use((req, res, next) => {
@@ -142,7 +147,24 @@ export class Server {
     });
 
     // body parsing
-    this.expressAppInstance.use(plugins.bodyParser.json({ limit: 100000000 })); // for parsing application/json
+    this.expressAppInstance.use(async (req, res, next) => {
+      if (req.headers['content-type'] === 'application/json') {
+        let data = '';
+        req.on('data', chunk => {
+          data += chunk;
+        });
+        req.on('end', () => {
+          try {
+            req.body = plugins.smartjson.parse(data);
+            next();
+          } catch (error) {
+            res.status(400).send('Invalid JSON');
+          }
+        });
+      } else {
+        next();
+      }
+    });
     this.expressAppInstance.use(plugins.bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded
 
     // robots

ts/servertools/classes.sitemap.ts

@@ -1,6 +1,6 @@
 import { Server } from './classes.server.js';
 import { Handler } from './classes.handler.js';
-import * as plugins from '../typedserver.plugins.js';
+import * as plugins from '../plugins.js';
 import { type IUrlInfo } from '@push.rocks/smartsitemap';
 
 export class Sitemap {
@@ -63,6 +63,6 @@ export class Sitemap {
    * adds urls to the current set of urls
    */
   public addUrls(urlsArg: IUrlInfo[]) {
-    this.urls = this.urls.concat(this.urls, urlsArg);
+    this.urls = this.urls.concat(urlsArg);
   }
-}
+}

ts/servertools/index.ts

@@ -1,6 +1,22 @@
+// Core utilities that don't depend on Express
+export * from './classes.compressor.js';
+
+// Legacy Express-based classes - deprecated, will be removed in next major version
+// These are kept for backward compatibility but should not be used for new code
+// Use SmartServe decorator-based controllers instead
+/** @deprecated Use SmartServe directly */
 export * from './classes.server.js';
+/** @deprecated Use SmartServe @Route decorator */
 export * from './classes.route.js';
+/** @deprecated Use SmartServe @Get/@Post decorators */
 export * from './classes.handler.js';
+/** @deprecated Use SmartServe static file serving */
 export * from './classes.handlerstatic.js';
+/** @deprecated Use SmartServe custom handler */
 export * from './classes.handlerproxy.js';
+/** @deprecated Use SmartServe TypedRouter integration */
 export * from './classes.handlertypedrouter.js';
+
+// Service worker utilities - uses legacy patterns, will be migrated
+import * as serviceworker from './tools.serviceworker.js';
+export { serviceworker };

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,

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';
 

ts/servertools/tools.serviceworker.ts

@@ -0,0 +1,92 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+
+import * as interfaces from '../../dist_ts_interfaces/index.js';
+import type { TypedServer } from '../classes.typedserver.js';
+
+// Lazy-loaded service worker bundle content
+let swBundleJs: string | null = null;
+let swBundleJsMap: string | null = null;
+
+const loadServiceWorkerBundle = async (): Promise<void> => {
+  if (swBundleJs === null) {
+    swBundleJs = (await plugins.fsInstance
+      .file(plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js'))
+      .encoding('utf8')
+      .read()) as string;
+  }
+  if (swBundleJsMap === null) {
+    swBundleJsMap = (await plugins.fsInstance
+      .file(plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js.map'))
+      .encoding('utf8')
+      .read()) as string;
+  }
+};
+
+let swVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
+  null;
+
+export const addServiceWorkerRoute = (
+  typedserverInstance: TypedServer,
+  swDataFunc: () => interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response']
+) => {
+  // Set the version info
+  swVersionInfo = swDataFunc();
+
+  // Service worker bundle handler
+  typedserverInstance.addRoute('/serviceworker/*splat', 'GET', async (request: Request) => {
+    await loadServiceWorkerBundle();
+    const url = new URL(request.url);
+    const path = url.pathname;
+
+    if (path === '/serviceworker/serviceworker.bundle.js' || path === '/serviceworker.bundle.js') {
+      return new Response(
+        swBundleJs + '\n' + `/** appSemVer: ${swVersionInfo?.appSemVer || 'not set'} */`,
+        {
+          status: 200,
+          headers: { 'Content-Type': 'text/javascript' },
+        }
+      );
+    } else if (
+      path === '/serviceworker/serviceworker.bundle.js.map' ||
+      path === '/serviceworker.bundle.js.map'
+    ) {
+      return new Response(swBundleJsMap, {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
+    return null;
+  });
+
+  // Typed request handler for service worker
+  typedserverInstance.addRoute('/sw-typedrequest', 'POST', async (request: Request) => {
+    try {
+      const body = await request.json();
+
+      // Create a local typed router for service worker requests
+      const typedrouter = new plugins.typedrequest.TypedRouter();
+
+      typedrouter.addTypedHandler(
+        new plugins.typedrequest.TypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>(
+          'serviceworker_versionInfo',
+          async () => {
+            return swDataFunc();
+          }
+        )
+      );
+
+      const response = await typedrouter.routeAndAddResponse(body);
+      return new Response(plugins.smartjson.stringify(response), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    } catch (error) {
+      return new Response(JSON.stringify({ error: 'Invalid request' }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+  });
+};

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';
 
@@ -10,7 +10,7 @@ export const redirectFrom80To443 = async () => {
   });
 
   smartexpressInstance.addRoute(
-    '*',
+    '/{*splat}',
     new Handler('ALL', async (req, res) => {
       res.redirect('https://' + req.headers.host + req.url);
     })

ts/typedserver.classes.typedserver.ts

@@ -1,232 +0,0 @@
-import * as plugins from './typedserver.plugins.js';
-import * as paths from './typedserver.paths.js';
-import * as interfaces from './interfaces/index.js';
-import * as servertools from './servertools/index.js';
-
-export interface IServerOptions {
-  /**
-   * serve a particular directory
-   */
-  serveDir?: string;
-
-  /**
-   * inject a reload script that takes care of live reloading
-   */
-  injectReload?: boolean;
-
-  /**
-   * 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 {
-  // static
-  // nothing here yet
-
-  // instance
-  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';
-  public typedsocket: plugins.typedsocket.TypedSocket;
-  public typedrouter = new plugins.typedrequest.TypedRouter();
-
-  public lastReload: number = Date.now();
-  public ended = false;
-  constructor(optionsArg: IServerOptions) {
-    const standardOptions: IServerOptions = {
-      port: 3000,
-      injectReload: false,
-      serveDir: null,
-      watch: false,
-      cors: true,
-    };
-    this.options = {
-      ...standardOptions,
-      ...optionsArg,
-    };
-
-    this.server = new servertools.Server(this.options);
-    // add routes to the smartexpress instance
-    this.server.addRoute(
-      '/typedserver/:request',
-      new servertools.Handler('ALL', async (req, res) => {
-        switch (req.params.request) {
-          case 'devtools':
-            res.setHeader('Content-Type', 'text/javascript');
-            res.status(200);
-            res.write(plugins.smartfile.fs.toStringSync(paths.bundlePath));
-            res.end();
-            break;
-          case 'reloadcheck':
-            console.log('got request for reloadcheck');
-            res.setHeader('Content-Type', 'text/plain');
-            res.status(200);
-            if (this.ended) {
-              res.write('end');
-              res.end();
-              return;
-            }
-            res.write(this.lastReload.toString());
-            res.end();
-        }
-      })
-    );
-    this.server.addRoute(
-      '/typedrequest',
-      new servertools.HandlerTypedRouter(this.typedrouter)
-    )
-  }
-
-  /**
-   * 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;
-            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,
-        })
-      );
-    } 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();
-    }
-
-    // lets start the server
-    await this.server.start();
-
-    this.typedsocket = await plugins.typedsocket.TypedSocket.createServer(
-      this.typedrouter,
-      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}`);
-  }
-
-  /**
-   * reloads the page
-   */
-  public async reload() {
-    this.lastReload = Date.now();
-    for (const connectionArg of await this.typedsocket.findAllTargetConnectionsByTag(
-      'typedserver_frontend'
-    )) {
-      const pushTime =
-        this.typedsocket.createTypedRequest<interfaces.IReq_PushLatestServerChangeTime>(
-          'pushLatestServerChangeTime',
-          connectionArg
-        );
-      pushTime.fire({
-        time: this.lastReload,
-      });
-    }
-  }
-
-  public async stop() {
-    this.ended = true;
-    await this.server.stop();
-    await this.typedsocket.stop();
-    if (this.smartchokInstance) {
-      await this.smartchokInstance.stop();
-    }
-  }
-
-  public async createServeDirHash() {
-    const serveDirHash = await plugins.smartfile.fs.fileTreeToHash(this.options.serveDir, '**/*');
-    this.serveHash = serveDirHash;
-    console.log('Current ServeDir hash: ' + serveDirHash);
-    this.serveDirHashSubject.next(serveDirHash);
-  }
-}

ts/typedserver.paths.ts

@@ -1,8 +0,0 @@
-import * as plugins from './typedserver.plugins.js';
-
-export const packageDir = plugins.path.join(
-  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
-  '../'
-);
-
-export const bundlePath = plugins.path.join(packageDir, './dist_ts_web/bundle.js');

ts/utilityservers/classes.serviceserver.ts

@@ -0,0 +1,49 @@
+import { TypedServer } from '../classes.typedserver.js';
+
+export interface ILoleServiceServerConstructorOptions {
+  addCustomRoutes?: (typedserver: TypedServer) => Promise<any>;
+  serviceName: string;
+  serviceVersion: string;
+  serviceDomain: string;
+  port?: number;
+}
+
+// the main service server
+export class UtilityServiceServer {
+  public options: ILoleServiceServerConstructorOptions;
+  public typedServer: TypedServer;
+
+  constructor(optionsArg: ILoleServiceServerConstructorOptions) {
+    this.options = optionsArg;
+  }
+
+  public async start() {
+    console.log('starting lole-serviceserver...');
+    this.typedServer = new TypedServer({
+      cors: true,
+      domain: this.options.serviceDomain,
+      forceSsl: false,
+      port: this.options.port || 3000,
+      robots: true,
+      defaultAnswer: async () => {
+        const InfoHtml = (await import('../infohtml/index.js')).InfoHtml;
+        return (
+          await InfoHtml.fromSimpleText(
+            `${this.options.serviceName} (version ${this.options.serviceVersion})`
+          )
+        ).htmlString;
+      },
+    });
+
+    // Add any custom routes
+    if (this.options.addCustomRoutes) {
+      await this.options.addCustomRoutes(this.typedServer);
+    }
+
+    await this.typedServer.start();
+  }
+
+  public async stop() {
+    await this.typedServer.stop();
+  }
+}

ts/utilityservers/classes.websiteserver.ts

@@ -0,0 +1,125 @@
+import * as interfaces from '../../dist_ts_interfaces/index.js';
+import { type IServerOptions, TypedServer } from '../classes.typedserver.js';
+import * as plugins from '../plugins.js';
+import * as servertools from '../servertools/index.js';
+
+export interface IUtilityWebsiteServerConstructorOptions {
+  addCustomRoutes?: (typedserver: TypedServer) => Promise<any>;
+  appSemVer?: string;
+  domain: string;
+  serveDir: string;
+  feedMetadata: IServerOptions['feedMetadata'];
+}
+
+/**
+ * the utility website server implements a best practice server for websites
+ * It supports:
+ *  * live reload
+ *  * serviceworker
+ *  * pwa manifest
+ */
+export class UtilityWebsiteServer {
+  public options: IUtilityWebsiteServerConstructorOptions;
+  public typedserver: TypedServer;
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  constructor(optionsArg: IUtilityWebsiteServerConstructorOptions) {
+    this.options = optionsArg;
+  }
+
+  /**
+   * Start the website server
+   */
+  public async start(portArg = 3000) {
+    this.typedserver = new TypedServer({
+      cors: true,
+      injectReload: true,
+      watch: true,
+      serveDir: this.options.serveDir,
+      domain: this.options.domain,
+      forceSsl: false,
+      manifest: {
+        name: this.options.domain,
+        short_name: this.options.domain,
+        start_url: '/',
+        display_override: ['window-controls-overlay'],
+        lang: 'en',
+        background_color: '#000000',
+        scope: '/',
+      },
+      port: portArg,
+
+      // features
+      robots: true,
+      sitemap: true,
+    });
+
+    let lswData: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] = {
+      appHash: 'xxxxxx',
+      appSemVer: this.options.appSemVer || 'x.x.x',
+    };
+
+    // -> /lsw* - anything regarding serviceworker
+    servertools.serviceworker.addServiceWorkerRoute(this.typedserver, () => {
+      return lswData;
+    });
+
+    // ads.txt handler
+    this.typedserver.addRoute('/ads.txt', 'GET', async () => {
+      const adsTxt =
+        ['google.com, pub-4104137977476459, DIRECT, f08c47fec0942fa0'].join('\n') + '\n';
+      return new Response(adsTxt, {
+        status: 200,
+        headers: { 'Content-Type': 'text/plain' },
+      });
+    });
+
+    // Asset broker manifest handler
+    this.typedserver.addRoute(
+      '/assetbroker/manifest/:manifestAsset',
+      'GET',
+      async (request: Request) => {
+        let manifestAssetName = (request as any).params?.manifestAsset;
+        if (manifestAssetName === 'favicon.png') {
+          manifestAssetName = `favicon_${this.options.domain
+            .replace('.', '')
+            .replace('losslesscom', 'lossless')}@2x_transparent.png`;
+        }
+        const fullOriginAssetUrl = `https://assetbroker.lossless.one/brandfiles/00general/${manifestAssetName}`;
+        console.log(`Getting ${manifestAssetName} from ${fullOriginAssetUrl}`);
+        const smartRequest = plugins.smartrequest.SmartRequest.create();
+        const response = await smartRequest.url(fullOriginAssetUrl).get();
+        const arrayBuffer = await response.arrayBuffer();
+        return new Response(arrayBuffer, {
+          status: 200,
+          headers: { 'Content-Type': 'image/png' },
+        });
+      }
+    );
+
+    // Add any custom routes
+    if (this.options.addCustomRoutes) {
+      await this.options.addCustomRoutes(this.typedserver);
+    }
+
+    // Subscribe to serve directory hash changes
+    this.typedserver.serveDirHashSubject.subscribe((appHash: string) => {
+      lswData = {
+        appHash,
+        appSemVer: '1.0.0',
+      };
+    });
+
+    // Setup the typedrouter chain
+    this.typedserver.typedrouter.addTypedRouter(this.typedrouter);
+
+    // Start everything
+    console.log('routes are all set. Starting up now!');
+    await this.typedserver.start();
+    console.log('typedserver started!');
+  }
+
+  public async stop() {
+    await this.typedserver.stop();
+  }
+}

ts/utilityservers/index.ts

@@ -0,0 +1,2 @@
+export * from './classes.serviceserver.js';
+export * from './classes.websiteserver.js';

ts_edgeworker/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: 'cloudflare-workers',
+  version: '1.0.192',
+  description: 'cloudflare-workers'
+}

ts_edgeworker/analytics/analyzer.ts

@@ -0,0 +1,83 @@
+
+import type { EdgeWorker } from '../classes.edgeworker.js';
+import type { WorkerEvent } from '../classes.workerevent.js';
+import * as plugins from '../plugins.js';
+import { SmartlogDestination } from './smartlog.js';
+
+export interface IAnalyticsData {
+  requestAgent: string;
+  requestUrl: string;
+  requestMethod: string;
+  requestStartTime: number;
+  responseStatus: number;
+  responseEndTime: number;
+}
+
+export class Analyzer {
+  cworkerEventRef: WorkerEvent;
+
+  public data: IAnalyticsData = {
+    requestAgent: 'unknown',
+    requestMethod: 'unknown',
+    requestUrl: 'unknown',
+    requestStartTime: 0,
+    responseStatus: 0,
+    responseEndTime: 0,
+  };
+
+  public finishedDeferred = plugins.smartpromise.defer();
+
+  constructor(cworkerEventRefArg: WorkerEvent) {
+    this.cworkerEventRef = cworkerEventRefArg;
+    this.smartlog.addLogDestination(new SmartlogDestination(this.cworkerEventRef.options.edgeWorkerRef));
+  }
+  public smartlog = new plugins.smartlog.Smartlog({
+    logContext: {
+      environment: 'production',
+      runtime: "cloudflare_workers",
+      zone: 'servezone',
+      company: 'Lossless GmbH',
+      companyunit: 'Lossless Cloud',
+      containerName: 'cloudflare_workers'
+    }
+  });
+
+  public setRequestData (optionsArg: {
+    requestAgent: string;
+    requestUrl: string;
+    requestMethod: string;
+  }) {
+    this.data = {
+      ...this.data,
+      ...{
+        requestAgent: optionsArg.requestAgent,
+        requestUrl: optionsArg.requestUrl,
+        requestMethod: optionsArg.requestMethod,
+        requestStartTime: Date.now()
+      }
+    };
+    
+  }
+
+  public setResponseData(optionsArg: {
+    responseStatus: number,
+    responseEndTime: number,
+  }) {
+    this.data = {
+      ...this.data,
+      ...{
+        responseStatus: optionsArg.responseStatus,
+        responseEndTime: optionsArg.responseEndTime
+      }
+    };
+    this.sendLogs();
+  }
+
+  public async sendLogs() {
+    await this.smartlog.log('info', `
+      Got a ${this.data.requestMethod} request from ${this.data.requestAgent} to
+      ${this.data.requestUrl}
+      that took ${this.data.responseEndTime - this.data.requestStartTime}ms to resolve with status ${this.data.responseStatus}.`, this.data);
+    this.finishedDeferred.resolve();
+  }
+}

ts_edgeworker/analytics/smartlog.ts

@@ -0,0 +1,26 @@
+import * as smartlogInterfaces from '@push.rocks/smartlog-interfaces';
+import type { EdgeWorker } from '../classes.edgeworker.js';
+
+export class SmartlogDestination implements smartlogInterfaces.ILogDestination {
+  public edgeWorkerRef: EdgeWorker;
+
+  constructor(edgeworkerRefArg: EdgeWorker) {
+    this.edgeWorkerRef = edgeworkerRefArg;
+  }
+
+  public async handleLog(logPackageArg: smartlogInterfaces.ILogPackage) {
+    if (this.edgeWorkerRef.options.smartlogConfig) {
+      const requestBody: smartlogInterfaces.ILogPackageAuthenticated = {
+        auth: this.edgeWorkerRef.options.smartlogConfig.token,
+        logPackage: logPackageArg,
+      };
+      await fetch(this.edgeWorkerRef.options.smartlogConfig.endpoint, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify(requestBody),
+      });
+    }
+  }
+}

ts_edgeworker/classes.domainrouter.ts

@@ -0,0 +1,67 @@
+import * as interfaces from './interfaces/index.js';
+import * as plugins from './plugins.js';
+import { WorkerEvent } from './classes.workerevent.js';
+
+import * as domainInstructions from './domaininstructions/index.js';
+
+export class DomainRouter {
+  private smartmatches: plugins.smartmatch.SmartMatch[] = [];
+
+  constructor() {
+    for (const key of Object.keys(domainInstructions.instructionObject)) {
+      this.smartmatches.push(new plugins.smartmatch.SmartMatch(key));
+    }
+  }
+
+  /**
+   *
+   * @param cworkerevent
+   */
+  public routeToResponder(cworkerevent: WorkerEvent) {
+    const match = this.smartmatches.find(smartmatchArg => {
+      return smartmatchArg.match(cworkerevent.request.url);
+    });
+    cworkerevent.responderInstruction = match
+      ? domainInstructions.instructionObject[match.wildcard]
+      : {
+          type: 'cache'
+        };
+  }
+
+  /**
+   * rendertronRouter
+   */
+  public checkWetherReRouteToRendertron(cworkerevent: WorkerEvent) {
+    let needsRendertron = false;
+    for (const botAgentIdentifier of domainInstructions.botUserAgents) {
+      if (needsRendertron) {
+        continue;
+      }
+      if (
+        cworkerevent.request.headers.get('user-agent') &&
+        cworkerevent.request.headers.get('user-agent').toLowerCase().includes(botAgentIdentifier.toLowerCase()) &&
+        !cworkerevent.request.url.includes('lossless.one')
+      ) {
+        needsRendertron = true;
+      }
+    }
+    if (needsRendertron) {
+      cworkerevent.routedThroughRendertron = true;
+    }
+  }
+
+  /**
+   * check wether this is a preflight request that should be handled
+   */
+  public checkWetherIsPreflight (cworkerevent: WorkerEvent) {
+    if (
+      cworkerevent.request.method === 'OPTIONS' &&
+      cworkerevent.request.headers.get('Origin') !== null &&
+      cworkerevent.request.headers.get('Access-Control-Request-Method') !== null &&
+      cworkerevent.request.headers.get('Access-Control-Request-Headers') !== null
+    ) {
+      cworkerevent.isPreflight = true;
+    }
+  }
+
+}

ts_edgeworker/classes.edgeworker.ts

@@ -0,0 +1,73 @@
+// imports
+import { WorkerEvent } from './classes.workerevent.js';
+import { DomainRouter } from './classes.domainrouter.js';
+import * as plugins from './plugins.js';
+import * as responders from './responders/index.js';
+
+export interface IEdgeWorkerOptions {
+  smartlogConfig?: {
+    endpoint: string;
+    token: string;
+  }
+}
+
+export class EdgeWorker {
+  public options: IEdgeWorkerOptions;
+  domainRouter: DomainRouter;
+
+  constructor(optionsArg: IEdgeWorkerOptions = {}) {
+    this.options = optionsArg;
+    this.domainRouter = new DomainRouter();
+    addEventListener('fetch', this.fetchFunction as any);
+  }
+
+  public async fetchFunction (eventArg: plugins.cloudflareTypes.FetchEvent) {
+    if (new URL(eventArg.request.url).pathname.startsWith('/socket.io')) {
+      return;
+    }
+  
+    const cworkerEvent = new WorkerEvent({
+      edgeWorkerRef: this,
+      event: eventArg,
+      passThroughOnException: true
+    });
+  
+    // lets answer basic reuest things
+    responders.timeoutResponder(cworkerEvent);
+    cworkerEvent.hasResponse ? null : await responders.urlFormattingResponder(cworkerEvent);
+  
+    // lets route the domain
+    this.domainRouter.routeToResponder(cworkerEvent);
+    this.domainRouter.checkWetherReRouteToRendertron(cworkerEvent);
+    this.domainRouter.checkWetherIsPreflight(cworkerEvent);
+  
+    // guardresponder
+    cworkerEvent.hasResponse ? null : await responders.guardResponder(cworkerEvent);
+  
+    // lets process all requests that need rendertron
+    cworkerEvent.hasResponse ? null : await responders.rendertronResponder(cworkerEvent);
+  
+    // lets process all requests that are preflight requests
+    cworkerEvent.hasResponse ? null : await responders.preflightResponder(cworkerEvent);
+  
+    switch (cworkerEvent.responderInstruction.type) {
+      case 'cache':
+        cworkerEvent.hasResponse ? null : await responders.cacheResponder(cworkerEvent);
+        break;
+      case 'origin':
+        cworkerEvent.hasResponse ? null : await responders.originResponder(cworkerEvent);
+        break;
+      case 'redirect':
+        cworkerEvent.hasResponse ? null : await responders.adsTxtResponder(cworkerEvent);
+        break;
+      case 'static':
+        cworkerEvent.hasResponse ? null : await responders.staticResponder(cworkerEvent);
+        break;
+      case 'ads.txt':
+        cworkerEvent.hasResponse ? null : await responders.adsTxtResponder(cworkerEvent);
+        break;
+    }
+    // cworkerEvent.hasResponse ? null : await responders.kvResponder(cworkerEvent);
+    cworkerEvent.hasResponse ? null : await responders.errorResponder(cworkerEvent);
+  };
+}

ts_edgeworker/classes.kvhandler.ts

@@ -0,0 +1,37 @@
+import * as interfaces from './interfaces/index.js';
+import * as plugins from './plugins.js';
+
+declare var lokv: plugins.cloudflareTypes.KVNamespace;
+
+/**
+ * an abstraction for the workerd KV store
+ */
+export class KVHandler {
+  private getSafeIdentifier(urlString: string) {
+    return encodeURI(urlString);
+  }
+
+  async getFromKv(keyIdentifier: string) {
+    const key = this.getSafeIdentifier(keyIdentifier);
+    const valueString = await lokv.get(key);
+    return valueString;
+  }
+
+  async putInKv(keyIdentifier: string, valueForStorage: string) {
+    const key = this.getSafeIdentifier(keyIdentifier);
+    const value = valueForStorage;
+    await lokv.put(key, value);
+    return null;
+  }
+
+  /**
+   * deletes a key/value from the cache
+   * @param keyIdentifier
+   */
+  async deleteInKv(keyIdentifier: string) {
+    const cacheKey = this.getSafeIdentifier(keyIdentifier);
+    await lokv.delete(cacheKey);
+  }
+}
+
+export const kvHandlerInstance = new KVHandler();

ts_edgeworker/classes.responsekv.ts

@@ -0,0 +1,46 @@
+import * as plugins from './plugins.js';
+import { kvHandlerInstance } from './classes.kvhandler.js';
+
+declare var lokv: plugins.cloudflareTypes.KVNamespace;
+
+interface IKVResponseObject {
+  headers: { [key: string]: string };
+  version: string;
+  body: string;
+}
+
+export class ResponseKv {
+  public async storeResponse(urlIdentifier: string, responseArg: any) {
+    const headers: { [key: string]: string } = {};
+    for (const kv of responseArg.headers.entries()) {
+      headers[kv[0]] = kv[1];
+    }
+    const kvResponseForStorage: IKVResponseObject = {
+      headers,
+      version: '1.0.0',
+      body: await responseArg.text()
+    };
+    await kvHandlerInstance.putInKv(urlIdentifier, JSON.stringify(kvResponseForStorage));
+  }
+
+  public async getResponse(urlIdentifier: string): Promise<Response> {
+    const kvValue = await kvHandlerInstance.getFromKv(urlIdentifier);
+    if (kvValue) {
+      let kvResponse: IKVResponseObject;
+      try {
+        kvResponse = JSON.parse(kvValue);
+      } catch (e) {
+        console.log(e);
+        return null;
+      }
+      const headers = new Headers();
+      for (const key of Object.keys(kvResponse.headers)) {
+        headers.append(key, kvResponse.headers[key]);
+      }
+      headers.append('SERVEZONE_ROUTE', 'CLOUDFLARE_EDGE_LOKV');
+      return new Response(kvResponse.body, { headers: headers });
+    } else {
+      return null;
+    }
+  }
+}

ts_edgeworker/classes.workerevent.ts

@@ -0,0 +1,102 @@
+import * as interfaces from './interfaces/index.js';
+import * as plugins from './plugins.js';
+import * as helpers from './helpers/index.js';
+import { DomainRouter } from './classes.domainrouter.js';
+import { Analyzer } from './analytics/analyzer.js';
+import type { EdgeWorker } from './classes.edgeworker.js';
+
+export interface ICworkerEventOptions {
+  event: plugins.cloudflareTypes.FetchEvent
+  edgeWorkerRef: EdgeWorker;
+  passThroughOnException?: boolean;
+}
+
+
+export class WorkerEvent {
+  public options: ICworkerEventOptions;
+
+  public analyzer: Analyzer;
+  private responseDeferred: plugins.smartpromise.Deferred<any>;
+  private waitUntilDeferred: plugins.smartpromise.Deferred<any>;
+  
+  private response: Response = null;
+  private waitList = [];
+
+  // routing settings
+  public responderInstruction: interfaces.IResponderInstruction;
+  public routedThroughRendertron: boolean = false;
+  public isPreflight: boolean = false;
+
+  public request: plugins.cloudflareTypes.Request;
+
+  public parsedUrl: URL;
+
+  constructor(optionsArg: ICworkerEventOptions) {
+    this.options = optionsArg;
+
+    // lets create an Analyzer for this request
+    this.analyzer = new Analyzer(this);
+
+    // lets make sure we always answer
+    this.options.passThroughOnException ? this.options.event.passThroughOnException() : null;
+
+    // lets set up some better asnyc behaviour
+    this.waitUntilDeferred = plugins.smartpromise.defer();
+    this.responseDeferred = plugins.smartpromise.defer();
+    this.addToWaitList(this.analyzer.finishedDeferred.promise);
+
+    // lets entangle the event with this class instance
+    this.request = this.options.event.request;
+
+    // lets start with analytics
+    this.analyzer.setRequestData({
+      requestAgent: this.request.headers.get('user-agent'),
+      requestMethod: this.request.method,
+      requestUrl: this.request.url
+    });
+
+
+    this.options.event.respondWith(this.responseDeferred.promise);
+    this.options.event.waitUntil(this.waitUntilDeferred.promise);
+
+    // lets parse the url
+    this.parsedUrl = new URL(this.request.url);
+
+    // lets check the waitlist
+    this.checkWaitList();
+    console.log(`Got request for ${this.request.url}`);
+  }
+
+  get hasResponse () {
+    let returnValue: boolean;
+    this.response ? returnValue = true : returnValue = false;
+    return returnValue;
+  }
+
+  public addToWaitList(promiseArg: Promise<any>) {
+    this.waitList.push(promiseArg);
+  }
+
+  private async checkWaitList() {
+    await this.responseDeferred.promise;
+    const currentWaitList = this.waitList;
+    this.waitList = [];
+    await Promise.all(currentWaitList);
+    if (this.waitList.length > 0) {
+      this.checkWaitList();
+    } else {
+      this.waitUntilDeferred.resolve();
+    }
+  }
+
+  public setResponse (responseArg: Response) {
+    this.response = responseArg;
+    this.responseDeferred.resolve(responseArg);
+    this.analyzer.setResponseData({
+      responseStatus: this.response.status,
+      responseEndTime: Date.now()
+    });
+  }
+
+  
+}

ts_edgeworker/domaininstructions/botuseragents.ts

@@ -0,0 +1,36 @@
+export const botUserAgents = [
+  // Baidu
+  'baiduspider',
+  'embedly',
+
+  // Facebook
+  'facebookexternalhit',
+
+  // Ghost
+  'Ghost',
+  
+  // Microsoft
+  'bingbot',
+  'BingPreview',
+  'linkedinbot',
+  'MissinglettrBot',
+  'msnbot',
+  'outbrain',
+  'pinterest',
+  'quora link preview',
+  'rogerbot',
+  'showyoubot',
+  'slackbot',
+  'TelegramBot',
+
+  // Twitter
+  'twitterbot',
+  'vkShare',
+  'W3C_Validator',
+
+  // WhatsApp
+  'whatsapp',
+
+  // woorank
+  'woorank'
+];

ts_edgeworker/domaininstructions/domaininstructions.ts

@@ -0,0 +1,7 @@
+import * as interfaces from '../interfaces/index.js';
+
+export const instructionObject: { [key: string]: interfaces.IResponderInstruction } = {
+  '*/ads.txt': {
+    type: 'ads.txt',
+  }
+};

ts_edgeworker/domaininstructions/index.ts

@@ -0,0 +1,2 @@
+export * from './botuseragents.js';
+export * from './domaininstructions.js';

ts_edgeworker/helpers/checks.ts

@@ -0,0 +1,9 @@
+import * as plugins from '../plugins.js';
+declare var lokv: plugins.cloudflareTypes.KVNamespace;
+export const checkLokv = () => {
+  if (!lokv) {
+    throw new Error('lokv not defined!');
+  } else {
+    console.log('lokv present!');
+  }
+};

ts_edgeworker/helpers/index.ts

@@ -0,0 +1 @@
+export * from './checks.js';

ts_edgeworker/index.ts

@@ -0,0 +1 @@
+export * from './classes.edgeworker.js';

ts_edgeworker/interfaces/custom.ts

@@ -0,0 +1,9 @@
+import { WorkerEvent } from "../classes.workerevent.js";
+
+export interface IResponderInstruction {
+  type: 'origin' | 'cache' | 'static' | 'redirect' | 'ads.txt';
+  cacheClientSideForMin?: number;
+  redirectUrl?: string;
+}
+
+export type TRequestResponser = (workerEventArg: WorkerEvent) => Promise<void>;

ts_edgeworker/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './custom.js';

ts_edgeworker/plugins.ts

@@ -0,0 +1,21 @@
+// @pushrocks scope
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartlogInterfaces from '@push.rocks/smartlog-interfaces';
+import * as smartmatch from '@push.rocks/smartmatch';
+import * as smartpromise from '@push.rocks/smartpromise';
+
+export {
+  smartdelay,
+  smartlog,
+  smartlogInterfaces,
+  smartmatch,
+  smartpromise
+};
+
+// cloudflarea
+import * as cloudflareTypes from '@cloudflare/workers-types';
+
+export {
+  cloudflareTypes
+}

ts_edgeworker/responders/adstxt.responder.ts

@@ -0,0 +1,14 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const adsTxtResponder: interfaces.TRequestResponser = async (cWorkerEventArg: WorkerEvent) => {
+  if (cWorkerEventArg.responderInstruction.type === 'ads.txt') {
+    const response = new Response('google.com, pub-4104137977476459, DIRECT, f08c47fec0942fa0\n', {
+      headers: {
+        'Content-Type': 'text/plain; charset=utf-8'
+      }
+    })
+    cWorkerEventArg.setResponse(response);
+  }
+
+};

ts_edgeworker/responders/cache.responder.ts

@@ -0,0 +1,92 @@
+import * as interfaces from '../interfaces/index.js';
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+import { kvHandlerInstance } from '../classes.kvhandler.js';
+
+declare const fetch: plugins.cloudflareTypes.Fetcher['fetch']; 
+
+declare var caches: any;
+export const cacheResponder: interfaces.TRequestResponser = async (cworkerEventArg: WorkerEvent) => {
+  const host = cworkerEventArg.request.headers.get('Host');
+  const appHashKey = `${host.toLowerCase()}_appHash`;
+  const appHash = await kvHandlerInstance.getFromKv(appHashKey);
+
+  const cache = caches.default;
+  let response: Response = await cache.match(cworkerEventArg.request);
+
+  if (
+    response &&
+    response.headers.get('appHash') &&
+    response.headers.get('appHash') !== appHash
+  ) {
+    response = null;
+  }
+
+  if (response) {
+    cworkerEventArg.setResponse(response);
+  } else {
+    response = await handleNewRequest(cworkerEventArg.request);
+    if (response) {
+      cworkerEventArg.addToWaitList(new Promise<void>(async (resolve, reject) => {
+        const newAppHash = response.headers.get('appHash');
+        if (newAppHash) {
+          await kvHandlerInstance.putInKv(appHashKey, newAppHash);
+        }
+        resolve();
+      }));
+      cworkerEventArg.addToWaitList(buildCacheResponse(cache, cworkerEventArg.request, response));
+      cworkerEventArg.setResponse(response);
+    }
+  }
+};
+
+/**
+ * @param {Request} originalRequest
+ */
+const handleNewRequest = async (originalRequest: plugins.cloudflareTypes.Request): Promise<Response> => {
+  console.log('answering from origin');
+  const originResponse: any = await fetch(
+    originalRequest
+  );
+
+  // lets capture status
+  if (originResponse.status > 399) {
+    return null;
+  }
+
+  const responseClientPassThroughStream = new TransformStream();
+  originResponse.body.pipeTo(responseClientPassThroughStream.writable);
+
+  // build response for client
+  const clientHeaders = new Headers();
+  for (const kv of originResponse.headers.entries()) {
+    clientHeaders.append(kv[0], kv[1]);
+  }
+  clientHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_ORIGIN_INITIAL');
+  const responseForClient = new Response(responseClientPassThroughStream.readable, {
+    ...originResponse,
+    headers: clientHeaders
+  });
+
+  // lets return the responses
+  return responseForClient;
+};
+
+const buildCacheResponse = async (cache, matchRequest: plugins.cloudflareTypes.Request, originResponse: any) => {
+  const cacheHeaders = new Headers();
+  for (const kv of originResponse.headers.entries()) {
+    cacheHeaders.append(kv[0], kv[1]);
+  }
+  cacheHeaders.delete('SERVEZONE_ROUTE');
+  cacheHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_CACHE');
+  cacheHeaders.delete('Cache-Control');
+  cacheHeaders.append('Cache-Control', 'public, max-age=60');
+  cacheHeaders.delete('Expires');
+  cacheHeaders.append('Expires', new Date(Date.now() + 60 * 1000).toUTCString());
+
+  const responseForCache = new Response(await originResponse.clone().body, {
+    ...originResponse,
+    headers: cacheHeaders
+  });
+  await cache.put(matchRequest, responseForCache);
+};

ts_edgeworker/responders/error.responder.ts

@@ -0,0 +1,6 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+export const errorResponder: interfaces.TRequestResponser = async (cWorkerEvent: WorkerEvent) => {
+  const errorResponse = await fetch('https://nullresolve.lossless.one/status/firewall');
+  cWorkerEvent.setResponse(errorResponse);
+};

ts_edgeworker/responders/guard.responder.ts

@@ -0,0 +1,8 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+export const guardResponder: interfaces.TRequestResponser = async (cWorkerEvent: WorkerEvent) => {
+  if (cWorkerEvent.parsedUrl.pathname.endsWith('.map')) {
+    const errorResponse = await fetch('https://nullresolve.lossless.one/status/firewall');
+    cWorkerEvent.setResponse(errorResponse);
+  }
+};

ts_edgeworker/responders/index.ts

@@ -0,0 +1,12 @@
+export * from './adstxt.responder.js';
+export * from './cache.responder.js';
+export * from './urlformatting.responder.js';
+export * from './error.responder.js';
+export * from './guard.responder.js';
+export * from './kv.responder.js';
+export * from './origin.responder.js';
+export * from './preflight.responder.js';
+export * from './redirect.reponder.js';
+export * from './rendertron.responder.js';
+export * from './static.responder.js';
+export * from './timeout.responder.js';

ts_edgeworker/responders/kv.responder.ts

@@ -0,0 +1,34 @@
+import * as interfaces from '../interfaces/index.js';
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+import { ResponseKv } from '../classes.responsekv.js';
+
+declare const fetch: plugins.cloudflareTypes.Fetcher['fetch']; 
+
+export const kvResponder: interfaces.TRequestResponser = async (cworkerEventArg: WorkerEvent) => {
+  const responseKvInstance = new ResponseKv();
+  let response = await responseKvInstance.getResponse(cworkerEventArg.request.url);
+  if (response) {
+    console.log('Got response from KV');
+  } else {
+    response = await handleNewRequest(cworkerEventArg.request, responseKvInstance);
+  }
+  cworkerEventArg.setResponse(response);
+};
+
+const handleNewRequest = async (request: plugins.cloudflareTypes.Request, responseKvInstance: ResponseKv) => {
+  const originResponse: any = await fetch(request);
+  // build response for cache
+  const cacheHeaders = new Headers();
+  for (const kv of originResponse.headers.entries()) {
+    cacheHeaders.append(kv[0], kv[1]);
+  }
+  cacheHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_KVRESPONSE');
+  cacheHeaders.append('Cache-Control', 'max-age=600');
+  const responseForKV = new Response(await originResponse.body, {
+    ...originResponse,
+    headers: cacheHeaders
+  });
+  await responseKvInstance.storeResponse(request.url, responseForKV.clone());
+  return responseForKV.clone();
+};

ts_edgeworker/responders/origin.responder.ts

@@ -0,0 +1,31 @@
+import * as interfaces from '../interfaces/index.js';
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+declare const fetch: plugins.cloudflareTypes.Fetcher['fetch'];
+
+export const originResponder: interfaces.TRequestResponser = async (eventArg: WorkerEvent) => {
+  const originResponse: any = await fetch(eventArg.request);
+  // lets capture status
+  if (originResponse.status > 399) {
+    return;
+  }
+
+  const headers = new Headers();
+  for (const kv of originResponse.headers.entries()) {
+    headers.append(kv[0], kv[1]);
+  }
+  headers.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_FASTORIGIN');
+
+  const responsePassThroughStream = new TransformStream();
+  originResponse.body.pipeTo(responsePassThroughStream.writable);
+
+  // response
+
+  const responseForClient = new Response(responsePassThroughStream.readable, {
+    ...originResponse,
+    headers,
+  });
+
+  eventArg.setResponse(responseForClient);
+};

ts_edgeworker/responders/preflight.responder.ts

@@ -0,0 +1,18 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const preflightResponder: interfaces.TRequestResponser = async (eventArg: WorkerEvent) => {
+  if (eventArg.isPreflight) {
+    const corsHeaders = new Headers();
+    corsHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_PREFLIGHT');
+    corsHeaders.append('Access-Control-Allow-Origin', '*');
+    corsHeaders.append('Access-Control-Allow-Methods', '*');
+    corsHeaders.append('Access-Control-Allow-Headers', '*');
+
+    eventArg.setResponse(
+      new Response(null, {
+        headers: corsHeaders,
+      })
+    );
+  }
+};

ts_edgeworker/responders/redirect.reponder.ts

@@ -0,0 +1,9 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const redirectResponder: interfaces.TRequestResponser = async (cWorkerEventArg: WorkerEvent) => {
+  if (cWorkerEventArg.responderInstruction.type === 'redirect') {
+    cWorkerEventArg.setResponse(Response.redirect(cWorkerEventArg.responderInstruction.redirectUrl, 302));
+  }
+
+};

ts_edgeworker/responders/rendertron.responder.ts

@@ -0,0 +1,22 @@
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const rendertronResponder = async (cworkerevent: WorkerEvent) => {
+  if (cworkerevent.routedThroughRendertron) {
+    const oldHeaders: any = cworkerevent.request.headers;
+    const rendertronHeaders = new Headers();
+    for (const kv of oldHeaders.entries()) {
+      const headerName = kv[0];
+      const headerValue = headerName === 'user-agent' ? 'Lossless Rendertron' : kv[1];
+      rendertronHeaders.append(headerName, headerValue);
+    }
+    const rendertronRequest = new Request(
+      `https://rendertron.lossless.one/render/${cworkerevent.request.url}`,
+      {
+        method: cworkerevent.request.method,
+        headers: rendertronHeaders
+      }
+    );
+    cworkerevent.setResponse(await fetch(rendertronRequest));
+  }
+};

ts_edgeworker/responders/static.responder.ts

@@ -0,0 +1,31 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const staticResponder: interfaces.TRequestResponser = async (cWorkerEventArg: WorkerEvent) => {
+  if (cWorkerEventArg.responderInstruction.type === 'static') {
+    const originResponse: any = await fetch(
+      `https://statichost.lossless.one/resolve?url=${encodeURI(cWorkerEventArg.request.url)}`
+    );
+
+    const cacheHeaders = new Headers();
+    for (const kv of originResponse.headers.entries()) {
+      cacheHeaders.append(kv[0], kv[1]);
+    }
+    cacheHeaders.delete('SERVEZONE_ROUTE');
+    cacheHeaders.append('SERVEZONE_ROUTE', 'LOSSLESS_EDGE_STATICHOST');
+    
+    if (cWorkerEventArg.responderInstruction.cacheClientSideForMin) {
+      cacheHeaders.delete('Cache-Control');
+      cacheHeaders.append('Cache-Control', `public, max-age=${cWorkerEventArg.responderInstruction.cacheClientSideForMin * 60}`);
+      cacheHeaders.delete('Expires');
+      cacheHeaders.append('Expires', new Date(Date.now() + cWorkerEventArg.responderInstruction.cacheClientSideForMin * 1000).toUTCString());
+    }
+
+    const responseForClient = new Response(await originResponse.clone().body, {
+      ...originResponse,
+      headers: cacheHeaders
+    });
+
+    cWorkerEventArg.setResponse(responseForClient);
+  }
+};

ts_edgeworker/responders/timeout.responder.ts

@@ -0,0 +1,23 @@
+import * as interfaces from '../interfaces/index.js';
+import * as plugins from '../plugins.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const timeoutResponder: interfaces.TRequestResponser = async (cWorkerEvent: WorkerEvent) => {
+  await plugins.smartdelay.delayFor(10000);
+  if (cWorkerEvent.routedThroughRendertron) {
+    await plugins.smartdelay.delayFor(10000);
+  }
+  if (!cWorkerEvent.hasResponse) {
+    const errorResponse = await fetch(
+      `https://nullresolve.lossless.one/custom?title=${encodeURI(
+        `Lossless Network: Request Cancellation!`
+      )}&heading=${encodeURI(`Error: Request Cancellation`)}&text=${encodeURI(
+        `Lossless Network could not decide how to respond to this request within 5 seconds. Therefore it timed out and has been canceled.
+        <p>requestUrl: ${cWorkerEvent.request.url}<br>
+        requestTime: ${Date.now()}<br>
+        referenceNumber: xxxxxx</p>`
+      )}`
+    );
+    cWorkerEvent.setResponse(errorResponse);
+  }
+};

ts_edgeworker/responders/urlformatting.responder.ts

@@ -0,0 +1,21 @@
+import * as interfaces from '../interfaces/index.js';
+import { WorkerEvent } from '../classes.workerevent.js';
+
+export const urlFormattingResponder: interfaces.TRequestResponser = async (eventArg: WorkerEvent) => {
+  let shouldCorrect = false;
+  const correctedUrl = new URL(eventArg.request.url);
+  if (eventArg.parsedUrl.hostname.startsWith('www.')) {
+    shouldCorrect = true;
+    correctedUrl.hostname = eventArg.parsedUrl.hostname.substring(
+      4,
+      eventArg.parsedUrl.hostname.length
+    );
+  }
+  if (eventArg.parsedUrl.protocol.startsWith('http:')) {
+    shouldCorrect = true;
+    correctedUrl.protocol = 'https:';
+  }
+  if (shouldCorrect) {
+    eventArg.setResponse(Response.redirect(`${correctedUrl.protocol}//${correctedUrl.host}${correctedUrl.pathname}${correctedUrl.search}`, 301));
+  }
+};

ts_edgeworker/versionhandler.ts

@@ -0,0 +1,7 @@
+import * as interfaces from './interfaces/index.js';
+
+export class VersionHandler {
+
+}
+
+export const versionHandlerInstance = new VersionHandler();

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,
+}

ts_interfaces/plugins.ts

@@ -0,0 +1,5 @@
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
+
+export {
+  typedrequestInterfaces,
+}

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;
 }>;

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;
+  }
+}

ts_web/00_commitinfo_data.ts

@@ -1,8 +0,0 @@
-/**
- * autocreated commitinfo by @pushrocks/commitinfo
- */
-export const commitinfo = {
-  name: '@api.global/typedserver',
-  version: '3.0.7',
-  description: 'easy serving of static files'
-}

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.'
+}

ts_web_inject/index.ts

@@ -1,5 +1,5 @@
 import * as plugins from './typedserver_web.plugins.js';
-import * as interfaces from '../ts/interfaces/index.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
 import { logger } from './typedserver_web.logger.js';
 logger.log('info', `TypedServer-Devtools initialized!`);
 

ts_web_inject/typedserver_web.infoscreen.ts

@@ -14,10 +14,10 @@ export class TypedserverInfoscreen extends LitElement {
   //INSTANCE
 
   @property()
-  private text = 'Hello';
+  accessor text = 'Hello';
 
   @property()
-  private success = false;
+  accessor success = false;
 
   public static styles = [
     css`

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'
+}

ts_web_serviceworker/classes.backend.ts

@@ -0,0 +1,155 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import { logger } from './logging.js';
+
+// Add type definitions for ServiceWorker APIs
+declare global {
+  interface ServiceWorkerGlobalScope extends EventTarget {
+    clients: Clients;
+    registration: ServiceWorkerRegistration;
+  }
+  
+  // Define Clients interface
+  interface Clients {
+    matchAll(options?: ClientQueryOptions): Promise<Client[]>;
+    openWindow(url: string): Promise<WindowClient>;
+    claim(): Promise<void>;
+    get(id: string): Promise<Client | undefined>;
+  }
+  
+  interface ClientQueryOptions {
+    includeUncontrolled?: boolean;
+    type?: 'window' | 'worker' | 'sharedworker' | 'all';
+  }
+  
+  interface Client {
+    id: string;
+    type: 'window' | 'worker' | 'sharedworker';
+    url: string;
+  }
+  
+  interface WindowClient extends Client {
+    focused: boolean;
+    visibilityState: 'hidden' | 'visible' | 'prerender' | 'unloaded';
+    focus(): Promise<WindowClient>;
+    navigate(url: string): Promise<WindowClient>;
+  }
+}
+
+/**
+ * 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() {
+    try {
+      logger.log('info', 'Triggering reload for all clients due to new version');
+      
+      // Send update message via DeesComms
+      // This will be picked up by clients that have registered a handler for 'serviceworker_newVersion'
+      await this.deesComms.postMessage({
+        method: 'serviceworker_newVersion',
+        request: {},
+        messageId: `sw_update_${Date.now()}`
+      });
+      
+      // As a fallback, also use the clients API to reload clients that might not catch the broadcast
+      // We need to type-cast self since TypeScript doesn't recognize ServiceWorker API
+      const swSelf = self as unknown as ServiceWorkerGlobalScope;
+      const clients = await swSelf.clients.matchAll({ type: 'window' });
+      logger.log('info', `Found ${clients.length} clients to reload`);
+      
+      for (const client of clients) {
+        if ('navigate' in client) {
+          // For modern browsers, navigate to the same URL to trigger reload
+          (client as any).navigate(client.url);
+          logger.log('info', `Navigated client to: ${client.url}`);
+        }
+      }
+    } catch (error) {
+      logger.log('error', `Failed to reload clients: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * display notification
+   */
+  public async addNotification(notificationArg: {
+    title: string;
+    body: string;
+  }) {
+    try {
+      // Check if we have permission to show notifications
+      const permission = self.Notification?.permission;
+      if (permission !== 'granted') {
+        logger.log('warn', `Cannot show notification: permission is ${permission}`);
+        return;
+      }
+      
+      // Type-cast self to ServiceWorkerGlobalScope
+      const swSelf = self as unknown as ServiceWorkerGlobalScope;
+      
+      // Use type assertion for notification options to include vibrate
+      const options = {
+        body: notificationArg.body,
+        icon: '/favicon.ico', // Assuming there's a favicon
+        badge: '/favicon.ico',
+        vibrate: [200, 100, 200]
+      } as NotificationOptions;
+      
+      await swSelf.registration.showNotification(notificationArg.title, options);
+      
+      logger.log('info', `Notification shown: ${notificationArg.title}`);
+    } catch (error) {
+      logger.log('error', `Failed to show notification: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  public async alert(alertText: string) {
+    // Since we can't directly show alerts from service worker context,
+    // we'll use notifications as a fallback
+    await this.addNotification({
+      title: 'Alert',
+      body: alertText
+    });
+    
+    // Send message to clients who might be able to show an actual alert
+    try {
+      await this.deesComms.postMessage({
+        method: 'serviceworker_alert',
+        request: { message: alertText },
+        messageId: `sw_alert_${Date.now()}`
+      });
+      logger.log('info', `Alert message sent to clients: ${alertText}`);
+    } catch (error) {
+      logger.log('error', `Failed to send alert to clients: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}

ts_web_serviceworker/classes.cachemanager.ts

@@ -0,0 +1,265 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './env.js';
+import { logger } from './logging.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+
+export class CacheManager {
+  public losslessServiceWorkerRef: ServiceWorker;
+
+  public usedCacheNames = {
+    runtimeCacheName: 'runtime'
+  };
+
+  constructor(losslessServiceWorkerRefArg: ServiceWorker) {
+    this.losslessServiceWorkerRef = losslessServiceWorkerRefArg;
+    this._setupCache();
+  }
+
+  /**
+   * Sets up the service worker's fetch event to intercept and cache responses.
+   */
+  private _setupCache = () => {
+    // Create a matching request. For internal requests, reuse the original; for external requests, create one with CORS settings.
+    const createMatchRequest = (requestArg: Request): Request => {
+      let matchRequest: Request;
+      try {
+        if (
+          requestArg.url.startsWith(
+            this.losslessServiceWorkerRef.serviceWindowRef.location.origin
+          )
+        ) {
+          // Internal request
+          matchRequest = requestArg;
+        } else {
+          // External request: create a new Request with appropriate CORS settings.
+          matchRequest = new Request(requestArg.url, {
+            method: requestArg.method,
+            headers: requestArg.headers,
+            mode: 'cors',
+            credentials: 'same-origin',
+            redirect: 'follow'
+          });
+        }
+      } catch (err) {
+        logger.log('error', `Error creating match request for ${requestArg.url}: ${err}`);
+        throw err;
+      }
+      return matchRequest;
+    };
+
+    /**
+     * Creates a 500 error response.
+     */
+    const create500Response = async (requestArg: Request, responseArg: Response): Promise<Response> => {
+      try {
+        const responseText = await responseArg.clone().text();
+        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 error 500</strong><br>
+              </div>
+              ServiceWorker is unable to fetch this request.<br>
+              <br>
+              <strong>Request URL:</strong> ${requestArg.url}<br>
+              <strong>Response Type:</strong> ${responseArg.type}<br>
+              <strong>Response Body:</strong> ${responseText}<br>
+            </body>
+          </html>
+        `,
+          {
+            headers: { 'Content-Type': 'text/html' },
+            status: 500
+          }
+        );
+      } catch (err) {
+        logger.log('error', `Error creating 500 response for ${requestArg.url}: ${err}`);
+        return new Response('Internal error', { status: 500 });
+      }
+    };
+
+    // Listen for fetch events on the service worker's controlled window.
+    this.losslessServiceWorkerRef.serviceWindowRef.addEventListener('fetch', async (fetchEventArg: any) => {
+      try {
+        const originalRequest: Request = fetchEventArg.request;
+        const parsedUrl = new URL(originalRequest.url);
+
+        // Block requests that we don't want the service worker to handle.
+        if (
+          parsedUrl.hostname.includes('paddle.com') ||
+          parsedUrl.hostname.includes('paypal.com') ||
+          parsedUrl.hostname.includes('reception.lossless.one') ||
+          parsedUrl.pathname.startsWith('/socket.io') ||
+          originalRequest.url.startsWith('https://umami.')
+        ) {
+          logger.log('note', `ServiceWorker not active for ${parsedUrl.toString()}`);
+          return;
+        }
+
+        // Create a deferred promise for the fetch event's response.
+        const done = plugins.smartpromise.defer<Response>();
+        fetchEventArg.respondWith(done.promise);
+
+        // Determine whether this request should be cached.
+        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.') ||
+          originalRequest.url.includes('https://unpkg.com') ||
+          originalRequest.url.includes('https://fonts.googleapis.com') ||
+          originalRequest.url.includes('https://fonts.gstatic.com')
+        ) {
+          // Kick off an asynchronous update check.
+          this.losslessServiceWorkerRef.updateManager.checkUpdate(this);
+
+          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;
+          }
+
+          logger.log('info', `NOTYETCACHED: Trying to cache ${matchRequest.url}`);
+          let newResponse: Response;
+          try {
+            newResponse = await fetch(matchRequest);
+          } catch (err: any) {
+            logger.log('error', `Fetch error for ${matchRequest.url}: ${err}`);
+            newResponse = await create500Response(matchRequest, new Response(err.message));
+          }
+
+          // Check if the response should be cached. In this version, if the response status is >299 or the response is opaque, we do not cache.
+          if (newResponse.status > 299 || newResponse.type === 'opaque') {
+            logger.log(
+              'error',
+              `NOTCACHED: Can't cache response for ${matchRequest.url} (status: ${newResponse.status}, type: ${newResponse.type})`
+            );
+            // Optionally, you can force a 500 response so errors are clearly visible.
+            done.resolve(await create500Response(matchRequest, newResponse));
+          } else {
+            try {
+              const cache = await caches.open(this.usedCacheNames.runtimeCacheName);
+              const responseToPutToCache = newResponse.clone();
+
+              // Create new headers preserving all except caching-related ones.
+              const headers = new Headers();
+              responseToPutToCache.headers.forEach((value, key) => {
+                if (!['Cache-Control', 'cache-control', 'Expires', 'expires', 'Pragma', 'pragma'].includes(key)) {
+                  headers.set(key, value);
+                }
+              });
+
+              // Ensure that CORS-related headers are present.
+              if (!headers.has('Access-Control-Allow-Origin')) {
+                headers.set('Access-Control-Allow-Origin', '*');
+              }
+              if (!headers.has('Access-Control-Allow-Methods')) {
+                headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+              }
+              if (!headers.has('Access-Control-Allow-Headers')) {
+                headers.set('Access-Control-Allow-Headers', 'Content-Type');
+              }
+              
+              // Set Cross-Origin-Resource-Policy
+              if (matchRequest.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin)) {
+                // For same-origin resources
+                headers.set('Cross-Origin-Resource-Policy', 'same-origin');
+              } else {
+                // For cross-origin resources that we explicitly allow
+                headers.set('Cross-Origin-Resource-Policy', 'cross-origin');
+              }
+
+              // Set caching headers - use modern Cache-Control only
+              headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
+
+              // IMPORTANT: Read the full response body as a blob to avoid issues (e.g., Safari locked streams).
+              const bodyBlob = await responseToPutToCache.blob();
+              const newCachedResponse = new Response(bodyBlob, {
+                status: responseToPutToCache.status,
+                statusText: responseToPutToCache.statusText,
+                headers
+              });
+
+              await cache.put(matchRequest, newCachedResponse);
+              logger.log('ok', `NOWCACHED: Cached response for ${matchRequest.url} for subsequent requests!`);
+              done.resolve(newResponse);
+            } catch (err) {
+              logger.log('error', `Error caching response for ${matchRequest.url}: ${err}`);
+              done.resolve(await create500Response(matchRequest, newResponse));
+            }
+          }
+        } else {
+          // For requests not intended for caching, simply fetch from the origin.
+          logger.log('ok', `NOTCACHED: Not caching ${originalRequest.url}. Fetching from origin...`);
+          try {
+            const originResponse = await fetch(originalRequest);
+            done.resolve(originResponse);
+          } catch (err: any) {
+            logger.log('error', `Fetch error for ${originalRequest.url}: ${err}`);
+            done.resolve(await create500Response(originalRequest, new Response(err.message)));
+          }
+        }
+      } catch (err) {
+        logger.log('error', `Unhandled fetch event error: ${err}`);
+      }
+    });
+  };
+
+  /**
+   * Cleans all caches.
+   * Should only be run when a new ServiceWorker is activated.
+   */
+  public cleanCaches = async (reasonArg = 'no reason given'): Promise<void> => {
+    try {
+      logger.log('info', `MAJOR CACHEEVENT: Cleaning caches now! Reason: ${reasonArg}`);
+      const cacheNames = await caches.keys();
+      const deletePromises = cacheNames.map((cacheToDelete) =>
+        caches.delete(cacheToDelete).then(() => {
+          logger.log('ok', `Deleted cache ${cacheToDelete}`);
+        })
+      );
+      await Promise.all(deletePromises);
+    } catch (err) {
+      logger.log('error', `Error cleaning caches: ${err}`);
+    }
+  };
+
+  /**
+   * Revalidates the runtime cache by fetching fresh responses and updating the cache.
+   */
+  public async revalidateCache(): Promise<void> {
+    try {
+      const runtimeCache = await caches.open(this.usedCacheNames.runtimeCacheName);
+      const cacheKeys = await runtimeCache.keys();
+      for (const requestArg of cacheKeys) {
+        try {
+          const clonedRequest = requestArg.clone();
+          const response = await plugins.smartpromise.timeoutWrap(fetch(clonedRequest), 5000);
+          if (response && response.status >= 200 && response.status < 300) {
+            await runtimeCache.delete(requestArg);
+            await runtimeCache.put(requestArg, response);
+          }
+        } catch (err) {
+          logger.log('error', `Error revalidating cache for ${requestArg.url}: ${err}`);
+        }
+      }
+    } catch (err) {
+      logger.log('error', `Error revalidating runtime cache: ${err}`);
+    }
+  }
+}

ts_web_serviceworker/classes.networkmanager.ts

@@ -0,0 +1,151 @@
+import * as plugins from './plugins.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+import { logger } from './logging.js';
+
+export class NetworkManager {
+  public serviceWorkerRef: ServiceWorker;
+  public webRequest: plugins.webrequest.WebrequestClient;
+  private isOffline: boolean = false;
+  private lastOnlineCheck: number = 0;
+  private readonly ONLINE_CHECK_INTERVAL = 30000; // 30 seconds
+
+  public previousState: string;
+
+  constructor(serviceWorkerRefArg: ServiceWorker) {
+    this.serviceWorkerRef = serviceWorkerRefArg;
+    this.webRequest = new plugins.webrequest.WebrequestClient();
+    
+    // Listen for connection changes
+    this.getConnection()?.addEventListener('change', () => {
+      this.updateConnectionStatus();
+    });
+
+    // Listen for online/offline events
+    self.addEventListener('online', () => {
+      this.isOffline = false;
+      logger.log('info', 'Device is now online');
+      this.updateConnectionStatus();
+    });
+
+    self.addEventListener('offline', () => {
+      this.isOffline = true;
+      logger.log('warn', 'Device is now offline');
+      this.updateConnectionStatus();
+    });
+  }
+
+  /**
+   * gets the connection
+   */
+  public getConnection() {
+    const navigatorLocal: any = self.navigator;
+    return navigatorLocal?.connection;
+  }
+
+  public getEffectiveType() {
+    return this.getConnection()?.effectiveType || '4g';
+  }
+
+  public updateConnectionStatus() {
+    const currentType = this.getEffectiveType();
+    logger.log('info', `Connection type changed from ${this.previousState} to ${currentType}`);
+    this.previousState = currentType;
+  }
+
+  /**
+   * Checks if the device is currently online by attempting to contact the server
+   * @returns Promise<boolean> true if online, false if offline
+   */
+  public async checkOnlineStatus(): Promise<boolean> {
+    const now = Date.now();
+    // Only check if enough time has passed since last check
+    if (now - this.lastOnlineCheck < this.ONLINE_CHECK_INTERVAL) {
+      return !this.isOffline;
+    }
+
+    try {
+      const response = await fetch('/sw-typedrequest', {
+        method: 'HEAD',
+        cache: 'no-cache'
+      });
+      this.isOffline = false;
+      this.lastOnlineCheck = now;
+      return true;
+    } catch (error) {
+      this.isOffline = true;
+      this.lastOnlineCheck = now;
+      logger.log('warn', 'Device appears to be offline');
+      return false;
+    }
+  }
+
+  /**
+   * Makes a network request with offline handling
+   * @param request The request to make
+   * @param options Additional options
+   * @returns Promise<Response>
+   */
+  public async makeRequest<T>(request: Request | string, options: {
+    timeoutMs?: number;
+    retries?: number;
+    backoffMs?: number;
+  } = {}): Promise<Response> {
+    const {
+      timeoutMs = 5000,
+      retries = 1,
+      backoffMs = 1000
+    } = options;
+
+    let lastError: Error | unknown;
+    for (let i = 0; i <= retries; i++) {
+      let timeoutId: number | undefined;
+      const controller = new AbortController();
+      
+      try {
+        const isOnline = await this.checkOnlineStatus();
+        if (!isOnline) {
+          throw new Error('Device is offline');
+        }
+
+        // Set up timeout
+        timeoutId = setTimeout(() => controller.abort(), timeoutMs) as unknown as number;
+
+        const response = await fetch(request, {
+          ...typeof request === 'string' ? {} : request,
+          signal: controller.signal
+        });
+
+        // Clear timeout on successful response
+        clearTimeout(timeoutId);
+        return response;
+      } catch (error) {
+        // Always clear timeout, even on error
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        
+        lastError = error;
+        logger.log('warn', `Request attempt ${i+1}/${retries+1} failed: ${error instanceof Error ? error.message : String(error)}`);
+        
+        // Check if this was an abort error (timeout)
+        if (error instanceof Error && error.name === 'AbortError') {
+          logger.log('warn', `Request timed out after ${timeoutMs}ms`);
+        }
+        
+        // Retry with backoff if we have retries left
+        if (i < retries) {
+          const backoffTime = backoffMs * (i + 1);
+          logger.log('info', `Retrying in ${backoffTime}ms...`);
+          await new Promise(resolve => setTimeout(resolve, backoffTime));
+        }
+      }
+    }
+
+    // Convert lastError to Error if it isn't already
+    const finalError = lastError instanceof Error 
+      ? lastError 
+      : new Error(typeof lastError === 'string' ? lastError : 'Unknown error during request');
+    
+    throw finalError;
+  }
+}

ts_web_serviceworker/classes.serviceworker.ts

@@ -0,0 +1,91 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './env.js';
+
+// imports
+import { CacheManager } from './classes.cachemanager.js';
+import { Deferred } from '@push.rocks/smartpromise';
+
+import { logger } from './logging.js';
+
+// imported classes
+import { UpdateManager } from './classes.updatemanager.js';
+import { NetworkManager } from './classes.networkmanager.js';
+import { TaskManager } from './classes.taskmanager.js';
+import { ServiceworkerBackend } from './classes.backend.js';
+
+export class ServiceWorker {
+  // STATIC
+
+  // INSTANCE
+  public serviceWindowRef: interfaces.ServiceWindow;
+  public leleServiceWorkerBackend: ServiceworkerBackend;
+
+  public cacheManager: CacheManager;
+
+  public updateManager: UpdateManager;
+  public networkManager: NetworkManager;
+  public taskManager: TaskManager;
+  public store: plugins.webstore.WebStore;
+
+  constructor(selfArg: interfaces.ServiceWindow) {
+    logger.log('info', `Service worker instantiating at ${Date.now()}`);
+    this.serviceWindowRef = selfArg;
+    this.leleServiceWorkerBackend = new ServiceworkerBackend({
+      self: selfArg,
+      purgeCache: async (reqArg) => {
+        await this.cacheManager.cleanCaches(),
+        logger.log('info', `cleaned caches in serviceworker as per request from frontend.`);
+        return {}
+      }
+    });
+
+    this.updateManager = new UpdateManager(this);
+    this.networkManager = new NetworkManager(this);
+    this.taskManager = new TaskManager(this);
+
+    this.cacheManager = new CacheManager(this);
+
+    this.store = new plugins.webstore.WebStore({
+      dbName: 'losslessServiceworker',
+      storeName: 'losslessServiceworker',
+    });
+
+    // =================================
+    // Installation and Activation
+    // =================================
+    this.serviceWindowRef.addEventListener('install', async (event: interfaces.ServiceEvent) => {
+      const done = new Deferred();
+      event.waitUntil(done.promise);
+      // its important to not go async before event.waitUntil
+      try {
+        logger.log('success', `service worker installed! TimeStamp = ${new Date().toISOString()}`);
+        selfArg.skipWaiting();
+        logger.log('note', `Called skip waiting!`);
+        done.resolve();
+      } catch (error) {
+        logger.log('error', `Service worker installation error: ${error}`);
+        done.reject(error);
+      }
+    });
+
+    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
+      try {
+        await selfArg.clients.claim();
+        logger.log('ok', 'Clients claimed successfully');
+        
+        await this.cacheManager.cleanCaches('new service worker loaded! :)');
+        logger.log('ok', 'Caches cleaned successfully');
+        
+        done.resolve();
+        logger.log('success', `Service worker activated at ${new Date().toISOString()}`);
+      } catch (error) {
+        logger.log('error', `Service worker activation error: ${error}`);
+        done.reject(error);
+      }
+    });
+  }
+}

ts_web_serviceworker/classes.taskmanager.ts

@@ -0,0 +1,24 @@
+import * as plugins from './plugins.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+
+/**
+ * Taskmanager
+ * should use times allocated by browser
+ */
+export class TaskManager {
+  public serviceworkerRef: ServiceWorker;
+  public taskmanager = new plugins.taskbuffer.TaskManager();
+
+  constructor(serviceWorkerRefArg: ServiceWorker) {
+    this.serviceworkerRef = serviceWorkerRefArg;
+    this.taskmanager.start();
+  }
+
+  public updateTask = new plugins.taskbuffer.Task({
+    name: 'updateTask',
+    taskFunction: async () => {
+      await this.serviceworkerRef.cacheManager.cleanCaches('a new app version has been communicated by the server.');
+    }
+  })
+
+}

ts_web_serviceworker/classes.typedrequestmanager.ts

@@ -0,0 +1 @@
+import * as plugins from './plugins.js';

ts_web_serviceworker/classes.updatemanager.ts

@@ -0,0 +1,157 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+import { logger } from './logging.js';
+import { CacheManager } from './classes.cachemanager.js';
+
+export class UpdateManager {
+  public lastUpdateCheck: number = 0;
+  public lastVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'];
+
+  public serviceworkerRef: ServiceWorker;
+
+  constructor(serviceWorkerRefArg: ServiceWorker) {
+    this.serviceworkerRef = serviceWorkerRefArg;
+  }
+
+  /**
+   * checks wether an update is needed
+   */
+  private readonly MAX_CACHE_AGE = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+  private readonly MIN_CHECK_INTERVAL = 100000; // 100 seconds in milliseconds
+  private readonly OFFLINE_GRACE_PERIOD = 7 * 24 * 60 * 60 * 1000; // 7 days grace period when offline
+  private lastCacheTimestamp: number = 0;
+
+  public async checkUpdate(cacheManager: CacheManager): Promise<boolean> {
+    const lswVersionInfoKey = 'versionInfo';
+    const cacheTimestampKey = 'cacheTimestamp';
+
+    // Initialize or load version info
+    if (!this.lastVersionInfo && !(await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
+      this.lastVersionInfo = {
+        appHash: '',
+        appSemVer: 'v0.0.0',
+      };
+    } else if (!this.lastVersionInfo && (await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
+      this.lastVersionInfo = await this.serviceworkerRef.store.get(lswVersionInfoKey);
+    }
+
+    // Load or initialize cache timestamp
+    if (await this.serviceworkerRef.store.check(cacheTimestampKey)) {
+      this.lastCacheTimestamp = await this.serviceworkerRef.store.get(cacheTimestampKey);
+    }
+
+    const now = Date.now();
+    const millisSinceLastCheck = now - this.lastUpdateCheck;
+    const cacheAge = now - this.lastCacheTimestamp;
+
+    // Check if we need to handle stale cache
+    if (cacheAge > this.MAX_CACHE_AGE) {
+      const isOnline = await this.serviceworkerRef.networkManager.checkOnlineStatus();
+      
+      if (isOnline) {
+        logger.log('info', `Cache is older than ${this.MAX_CACHE_AGE}ms, forcing update...`);
+        await this.forceUpdate(cacheManager);
+        return true;
+      } else if (cacheAge > this.OFFLINE_GRACE_PERIOD) {
+        // If we're offline and beyond grace period, warn but continue serving cached content
+        logger.log('warn', `Cache is stale and device is offline. Cache age: ${cacheAge}ms. Using cached content with warning.`);
+        // We could potentially show a warning to the user here
+        return false;
+      } else {
+        logger.log('info', `Cache is stale but device is offline. Within grace period. Using cached content.`);
+        return false;
+      }
+    }
+
+    // Regular update check interval
+    if (millisSinceLastCheck < this.MIN_CHECK_INTERVAL && cacheAge < this.MAX_CACHE_AGE) {
+      return false;
+    }
+    logger.log('info', 'checking for update of the app by comparing app hashes...');
+    this.lastUpdateCheck = now;
+    const currentVersionInfo = await this.getVersionInfoFromServer();
+    logger.log('info', `old versionInfo: ${JSON.stringify(this.lastVersionInfo)}`);
+    logger.log('info', `current versionInfo: ${JSON.stringify(currentVersionInfo)}`);
+    const needsUpdate = this.lastVersionInfo.appHash !== currentVersionInfo.appHash ? true : false;
+    if (needsUpdate) {
+      logger.log('info', 'Caches need to be updated');
+      logger.log('info', 'starting a debounced update task');
+      this.performAsyncUpdateDebouncedTask.trigger();
+      this.lastVersionInfo = currentVersionInfo;
+      await this.serviceworkerRef.store.set(lswVersionInfoKey, this.lastVersionInfo);
+      
+      // Update cache timestamp
+      this.lastCacheTimestamp = now;
+      await this.serviceworkerRef.store.set('cacheTimestamp', now);
+    } else {
+      logger.log('ok', 'caches are still valid, performing revalidation in a bit...');
+      this.performAsyncCacheRevalidationDebouncedTask.trigger();
+      
+      // Update cache timestamp after successful revalidation
+      this.lastCacheTimestamp = now;
+      await this.serviceworkerRef.store.set('cacheTimestamp', now);
+    }
+  }
+
+  /**
+   * gets the apphash from the server
+   */
+  public async getVersionInfoFromServer() {
+    try {
+      const getAppHashRequest = new plugins.typedrequest.TypedRequest<
+        interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo
+      >('/sw-typedrequest', 'serviceworker_versionInfo');
+      
+      // Use networkManager for the request with retries and timeout
+      const response = await getAppHashRequest.fire({});
+
+      return response;
+    } catch (error) {
+      logger.log('warn', `Failed to get version info from server: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // tasks
+  /**
+   * this task is executed once we know that there is a new version available
+   */
+  private async forceUpdate(cacheManager: CacheManager) {
+    try {
+      logger.log('info', 'Forcing cache update due to staleness');
+      const currentVersionInfo = await this.getVersionInfoFromServer();
+      
+      // Only proceed with cache cleaning if we successfully got new version info
+      await this.serviceworkerRef.cacheManager.cleanCaches('Cache is stale, forcing update.');
+      this.lastVersionInfo = currentVersionInfo;
+      await this.serviceworkerRef.store.set('versionInfo', this.lastVersionInfo);
+      this.lastCacheTimestamp = Date.now();
+      await this.serviceworkerRef.store.set('cacheTimestamp', this.lastCacheTimestamp);
+      await this.serviceworkerRef.leleServiceWorkerBackend.triggerReloadAll();
+    } catch (error) {
+      logger.log('error', `Failed to force update: ${error.message}. Keeping existing cache.`);
+      // If update fails, we'll keep using the existing cache
+      throw error;
+    }
+  }
+
+  public performAsyncUpdateDebouncedTask = new plugins.taskbuffer.TaskDebounced({
+    name: 'performAsyncUpdate',
+    taskFunction: async () => {
+      logger.log('info', 'trying to update PWA with serviceworker');
+      await this.serviceworkerRef.cacheManager.cleanCaches('a new app version has been communicated by the server.');
+      // lets notify all current clients about the update
+      await this.serviceworkerRef.leleServiceWorkerBackend.triggerReloadAll();
+    },
+    debounceTimeInMillis: 2000,
+  });
+
+  public performAsyncCacheRevalidationDebouncedTask = new plugins.taskbuffer.TaskDebounced({
+    name: 'performAsyncCacheRevalidation',
+    taskFunction: async () => {
+      await this.serviceworkerRef.cacheManager.revalidateCache();
+    },
+    debounceTimeInMillis: 6000
+  });
+}

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;

ts_web_serviceworker/index.ts

@@ -0,0 +1,7 @@
+// TypeScript declatations
+import * as env from './env.js';
+declare var self: env.ServiceWindow;
+
+import { ServiceWorker } from './classes.serviceworker.js';
+
+const sw = new ServiceWorker(self);

ts_web_serviceworker/logging.ts

@@ -0,0 +1,17 @@
+import * as smartlog from '@push.rocks/smartlog';
+import { SmartlogDestinationDevtools } from '@push.rocks/smartlog-destination-devtools';
+
+export const logger = new smartlog.Smartlog({
+  logContext: {
+    company: 'Lossless GmbH',
+    companyunit: 'Lossless Cloud',
+    containerName: 'web',
+    environment: 'production',
+    runtime: 'chrome',
+    zone: 'servezone'
+  },
+  minimumLogLevel: 'info'
+});
+
+logger.addLogDestination(new SmartlogDestinationDevtools());
+logger.log('note', 'serviceworker console initialized!');

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,
+}

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'
+}

ts_web_serviceworker_client/classes.actionmanager.ts

@@ -0,0 +1,58 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import { logger } from './logging.js';
+
+/**
+ * MessageManager implements two ways of serviceworker communication
+ * * the serviceWorker method
+ * * the deesComms method using BroadcastChannel
+ */
+export class ActionManager {
+  public deesComms = new plugins.deesComms.DeesComms();
+
+  constructor() {
+    // lets define handlers on the client/tab side
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IMessage_Serviceworker_Client_UpdateInfo>('serviceworker_newVersion', async req => {
+      setTimeout(() => {
+        window.location.reload();
+      }, 200);
+      return {};
+    });
+  }
+
+  public async waitForServiceWorkerConnection () {
+    console.log('waiting for service worker connection...')
+    const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Client_Serviceworker_ConnectionPolling>('broadcastConnectionPolling');
+    let connected = false;
+    while (!connected) {
+      tr.fire({
+        tabId: '123'
+      }).then(response => {
+        if (response.serviceworkerId) {
+          console.log('connected to serviceworker!');
+          connected = true;
+        }
+      }).catch();
+      await plugins.smartdelay.delayFor(777);
+      if (!connected) {
+        // lets wake it up.
+        navigator.serviceWorker.controller.postMessage({
+          type: 'wakeUpCall',
+        });
+      }
+    }
+    console.log('ok, got serviceworker connection.')
+  }
+
+  public async purgeServiceWorkerCache () {
+    const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_PurgeServiceWorkerCache>('purgeServiceWorkerCache');
+    const response = await tr.fire({});
+    return response;
+  }
+
+  public async getVersionInfo () {
+    const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>('serviceworker_versionInfo');
+    const response = await tr.fire({});
+    return response;
+  }
+}