3.0.78

fix(servertools): Fix wildcard path extraction for static/proxy handlers, correct serviceworker route, add local settings and test typo fix
3.0.77
2025-09-03 12:33:04 +00:00 · 2025-09-03 12:33:04 +00:00 · 2025-08-17 12:49:28 +00:00 · 2025-08-17 12:49:28 +00:00 · 2025-08-17 08:14:08 +00:00 · 2025-08-17 08:14:08 +00:00
24 changed files with 4139 additions and 3249 deletions
--- a/.serena/.gitignore
+++ b/.serena/.gitignore
@@ -0,0 +1 @@
+/cache
--- a/.serena/project.yml
+++ b/.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"
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,200 @@
 # Changelog

+## 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.

--- a/npmextra.json
+++ b/npmextra.json
@@ -6,7 +6,7 @@
    "projectType": "npm",
    "module": {
      "githost": "code.foss.global",
-      "gitscope": "pushrocks",
+      "gitscope": "api.global",
      "gitrepo": "typedserver",
      "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
      "npmPackagename": "@api.global/typedserver",
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@api.global/typedserver",
-  "version": "3.0.54",
+  "version": "3.0.78",
  "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
  "type": "module",
  "exports": {
@@ -13,7 +13,7 @@
    "./web_serviceworker_client": "./dist_ts_web_serviceworker_client/index.js"
  },
  "scripts": {
-    "test": "npm run build && tstest test/",
+    "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",
@@ -21,7 +21,7 @@
  },
  "repository": {
    "type": "git",
-    "url": "https://github.com/pushrocks/easyserve.git"
+    "url": "https://code.foss.global/api.global/typedserver.git"
  },
  "keywords": [
    "TypeScript",
@@ -42,7 +42,7 @@
  "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/**/*",
@@ -56,21 +56,21 @@
    "npmextra.json",
    "readme.md"
  ],
-  "homepage": "https://github.com/pushrocks/easyserve",
+  "homepage": "https://code.foss.global/api.global/typedserver",
  "dependencies": {
    "@api.global/typedrequest": "^3.1.10",
    "@api.global/typedrequest-interfaces": "^3.0.19",
    "@api.global/typedsocket": "^3.0.1",
-    "@cloudflare/workers-types": "^4.20241224.0",
+    "@cloudflare/workers-types": "^4.20250816.0",
    "@design.estate/dees-comms": "^1.0.27",
-    "@push.rocks/lik": "^6.1.0",
-    "@push.rocks/smartchok": "^1.0.34",
+    "@push.rocks/lik": "^6.2.2",
+    "@push.rocks/smartchok": "^1.1.1",
    "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartenv": "^5.0.12",
+    "@push.rocks/smartenv": "^5.0.13",
    "@push.rocks/smartfeed": "^1.0.11",
-    "@push.rocks/smartfile": "^11.0.23",
+    "@push.rocks/smartfile": "^11.2.5",
    "@push.rocks/smartjson": "^5.0.20",
-    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartlog": "^3.1.8",
    "@push.rocks/smartlog-destination-devtools": "^1.0.12",
    "@push.rocks/smartlog-interfaces": "^3.0.2",
    "@push.rocks/smartmanifest": "^2.0.2",
@@ -78,34 +78,34 @@
    "@push.rocks/smartmime": "^2.0.4",
    "@push.rocks/smartntml": "^2.0.8",
    "@push.rocks/smartopen": "^2.0.0",
-    "@push.rocks/smartpath": "^5.0.18",
-    "@push.rocks/smartpromise": "^4.0.4",
-    "@push.rocks/smartrequest": "^2.0.23",
-    "@push.rocks/smartrx": "^3.0.7",
+    "@push.rocks/smartpath": "^6.0.0",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartrequest": "^4.2.1",
+    "@push.rocks/smartrx": "^3.0.10",
    "@push.rocks/smartsitemap": "^2.0.3",
    "@push.rocks/smartstream": "^3.2.5",
    "@push.rocks/smarttime": "^4.1.1",
    "@push.rocks/taskbuffer": "^3.1.7",
    "@push.rocks/webrequest": "^3.0.37",
    "@push.rocks/webstore": "^2.0.20",
-    "@tsclass/tsclass": "^4.2.0",
-    "@types/express": "^4.17.21",
-    "body-parser": "^1.20.3",
+    "@tsclass/tsclass": "^9.2.0",
+    "@types/express": "^5.0.3",
+    "body-parser": "^2.2.0",
    "cors": "^2.8.5",
-    "express": "^4.21.2",
+    "express": "^5.1.0",
    "express-force-ssl": "^0.3.2",
-    "lit": "^3.2.1"
+    "lit": "^3.3.1"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.2.0",
-    "@git.zone/tsbundle": "^2.1.0",
+    "@git.zone/tsbuild": "^2.6.4",
+    "@git.zone/tsbundle": "^2.5.1",
    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.90",
-    "@push.rocks/tapbundle": "^5.5.3",
-    "@types/node": "^22.10.2"
+    "@git.zone/tstest": "^2.3.4",
+    "@types/node": "^22.14.0"
  },
  "private": false,
  "browserslist": [
    "last 1 chrome versions"
-  ]
+  ],
+  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6"
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.md
+++ b/readme.md
@@ -1,52 +1,168 @@
-```markdown
 # @api.global/typedserver
-Easy serving of static files

-## Install
-To install @api.global/typedserver, run the following command in your terminal:
+A TypeScript-based framework for serving static files with advanced features including live reloading, compression, and type-safe API requests. Part of the @api.global ecosystem, it integrates seamlessly with @api.global/typedrequest for type-safe HTTP requests and @api.global/typedsocket for WebSocket communication.
+
+## Features
+
+- **Type-Safe API Ecosystem**:
+  - HTTP Requests via @api.global/typedrequest
+  - WebSocket Support via @api.global/typedsocket
+  - Full TypeScript support across all endpoints
+- **Service Worker Integration**: Advanced caching and offline capabilities
+- **Edge Worker Support**: Optimized edge computing capabilities
+- **Live Reload**: Automatic browser refresh on file changes
+- **Compression**: Built-in support for response compression
+- **CORS Management**: Flexible cross-origin resource sharing
+- **TypeScript First**: Built with and for TypeScript
+
+## Components
+
+### Core Server (`ts/`)
+- Static file serving with Express
+- Type-safe request handling
+- Live reload functionality
+- Compression middleware
+
+### Service Worker (`ts_web_serviceworker/`)
+- `CacheManager`: Advanced caching strategies
+- `NetworkManager`: Request/response handling
+- `UpdateManager`: Cache invalidation and updates
+- `ServiceWorker`: Core service worker implementation
+
+### Edge Worker (`ts_edgeworker/`)
+- Edge computing capabilities
+- Request/response transformation
+- Edge caching strategies
+
+### Web Inject (`ts_web_inject/`)
+- Live reload script injection
+- Runtime dependency management
+- Dynamic module loading
+
+## Installation

 ```bash
-npm install @api.global/typedserver --save
+npm install @api.global/typedserver
 ```

-This will add `@api.global/typedserver` to your project's dependencies.
-
-## Usage
-
-`@api.global/typedserver` is designed to make serving static files and handling web requests in a TypeScript environment easy and efficient. It leverages Express under the hood, providing a powerful API for web server creation with additional utilities for live reloading, typed requests/responses, and more, embracing TypeScript's static typing advantages.
-
-### Setting up a Basic Web Server
-
-The following example demonstrates how to set up a basic web server serving files from a directory.
+## Quick Start

 ```typescript
 import { TypedServer } from '@api.global/typedserver';

-const serverOptions = {
-  port: 8080, // Port to listen on
-  serveDir: 'public', // Directory to serve static files from
-  watch: true, // Enable live reloading of changes
-  injectReload: true, // Inject live reload script into served HTML files
-  cors: true // Enable CORS
-};
+const server = new TypedServer({
+  port: 3000,
+  serveDir: './public',
+  watch: true,
+  compression: true
+});

-const typedServer = new TypedServer(serverOptions);
-
-async function startServer() {
-  await typedServer.start();
-  console.log(`Server is running on http://localhost:${serverOptions.port}`);
-}
-
-startServer().catch(console.error);
+server.start();
 ```

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

-### Using Typed Requests and Responses
+### HTTP Requests with TypedRequest
+```typescript
+import { TypedRequest } from '@api.global/typedrequest';

-`TypedServer` supports typed requests and responses, making API development more robust and maintainable. Define your request and response types, and use them to type-check incoming requests and their responses.
+// Define your request/response interface
+interface IUserRequest {
+  method: 'getUser';
+  request: { userId: string };
+  response: { username: string; email: string; };
+}

-First, define the types:
+// Create and use a typed request
+const getUserRequest = new TypedRequest<IUserRequest>('/api/users', 'getUser');
+const user = await getUserRequest.fire({ userId: '123' });
+```
+
+### WebSocket Communication
+```typescript
+import { TypedSocket } from '@api.global/typedsocket';
+
+// Server setup
+const typedRouter = new TypedRouter();
+const server = await TypedSocket.createServer(typedRouter);
+
+// Client connection
+const client = await TypedSocket.createClient(typedRouter, 'ws://localhost:3000');
+
+// Type-safe real-time messaging
+interface IChatMessage {
+  method: 'sendMessage';
+  request: { text: string };
+  response: { id: string; timestamp: number; };
+}
+```
+
+## Advanced Usage
+
+### Service Worker Setup
+
+```typescript
+import { ServiceWorker } from '@api.global/typedserver/web_serviceworker';
+
+const sw = new ServiceWorker({
+  cacheStrategy: 'network-first',
+  offlineSupport: true
+});
+
+sw.register();
+```
+
+### Edge Worker Configuration
+
+```typescript
+import { EdgeWorker } from '@api.global/typedserver/edgeworker';
+
+const edge = new EdgeWorker({
+  transforms: ['compress', 'minify'],
+  caching: true
+});
+```
+
+## Configuration
+
+### Server Options
+```typescript
+interface IServerOptions {
+  port?: number;
+  host?: string;
+  serveDir: string;
+  watch?: boolean;
+  compression?: boolean;
+  cors?: boolean | CorsOptions;
+  cache?: CacheOptions;
+}
+```
+
+### Cache Strategies
+```typescript
+type CacheStrategy = 
+  | 'network-first'
+  | 'cache-first'
+  | 'stale-while-revalidate';
+```
+
+## API Reference
+
+See [API Documentation](https://api.global/docs/typedserver) for detailed API reference.
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+## License
+
+MIT License - see LICENSE for details.
+
+Task Venture Capital GmbH © 2024

 ```typescript
 // Define a request type
--- a/test/test.reload.ts
+++ b/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';
--- a/test/test.server.ts
+++ b/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());
 });
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: '@api.global/typedserver',
-  version: '3.0.54',
+  version: '3.0.78',
  description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }
--- a/ts/classes.typedserver.ts
+++ b/ts/classes.typedserver.ts
@@ -81,6 +81,7 @@ export class TypedServer {

  public lastReload: number = Date.now();
  public ended = false;
+  
  constructor(optionsArg: IServerOptions) {
    const standardOptions: IServerOptions = {
      port: 3000,
@@ -117,26 +118,39 @@ export class TypedServer {
            }
            res.write(this.lastReload.toString());
            res.end();
+            break;
+          default:
+            res.status(404);
+            res.write('Unknown request type');
+            res.end();
+            break;
        }
      })
    );
    this.server.addRoute(
      '/typedrequest',
      new servertools.HandlerTypedRouter(this.typedrouter)
-    )
+    );
  }

  /**
   * 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.'
+      );
+    }
+
    if (this.options.serveDir) {
      this.server.addRoute(
-        '/*',
+        '/*splat',
        new servertools.HandlerStatic(this.options.serveDir, {
          responseModifier: async (responseArg) => {
-            let fileString = responseArg.responseContent.toString();
            if (plugins.path.parse(responseArg.path).ext === '.html') {
+              let fileString = responseArg.responseContent.toString();
              const fileStringArray = fileString.split('<head>');
              if (this.options.injectReload && fileStringArray.length === 2) {
                fileStringArray[0] = `${fileStringArray[0]}<head>
@@ -152,8 +166,9 @@ export class TypedServer {
                `;
                fileString = fileStringArray.join('');
                console.log('injected typedserver script.');
+                responseArg.responseContent = Buffer.from(fileString);
              } else if (this.options.injectReload) {
-                console.log('Could not insert typedserver script');
+                console.log('Could not insert typedserver script - no <head> tag found');
              }
            }
            const headers = responseArg.headers;
@@ -164,7 +179,8 @@ export class TypedServer {
            return {
              headers,
              path: responseArg.path,
-              responseContent: Buffer.from(fileString),
+              responseContent: responseArg.responseContent,
+              travelData: responseArg.travelData,
            };
          },
          serveIndexHtmlDefault: true,
@@ -172,40 +188,44 @@ export class TypedServer {
          preferredCompressionMethod: this.options.preferredCompressionMethod,
        })
      );
-    } else if (this.options.injectReload) {
-      throw new Error(
-        'You set to inject the reload script without a serve dir. This is not supported at the moment.'
-      );
    }
+    
    if (this.options.watch && this.options.serveDir) {
-      this.smartchokInstance = new plugins.smartchok.Smartchok([this.options.serveDir]);
-      await this.smartchokInstance.start();
-      (await this.smartchokInstance.getObservableFor('change')).subscribe(async () => {
+      try {
+        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();
-        this.reload();
-      });
-      await this.createServeDirHash();
+      } catch (error) {
+        console.error('Failed to initialize file watching:', error);
+        // Continue without file watching rather than crashing
+      }
    }

    // lets start the server
    await this.server.start();

-    this.typedsocket = await plugins.typedsocket.TypedSocket.createServer(
-      this.typedrouter,
-      this.server
-    );
+    try {
+      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}`);
+      // lets setup typedrouter
+      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);
+      // Continue without WebSocket support rather than crashing
+    }
  }

  /**
@@ -213,33 +233,80 @@ export class TypedServer {
   */
  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>(
+    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',
-          connectionArg
+          connection
        );
-      pushTime.fire({
-        time: this.lastReload,
-      });
+        pushTime.fire({
+          time: this.lastReload,
+        });
+      }
+    } catch (error) {
+      console.error('Failed to notify clients about reload:', error);
    }
  }

-  public async stop() {
+  /**
+   * Stops the server and cleans up resources
+   */
+  public async stop(): Promise<void> {
    this.ended = true;
-    await this.server.stop();
-    await this.typedsocket.stop();
-    if (this.smartchokInstance) {
-      await this.smartchokInstance.stop();
+    
+    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 server
+    if (this.server) {
+      tasks.push(stopWithErrorHandling(() => this.server.stop(), 'server'));
    }
+    
+    // Stop TypedSocket
+    if (this.typedsocket) {
+      tasks.push(stopWithErrorHandling(() => this.typedsocket.stop(), 'TypedSocket'));
+    }
+    
+    // Stop file watcher
+    if (this.smartchokInstance) {
+      tasks.push(stopWithErrorHandling(() => this.smartchokInstance.stop(), 'file watcher'));
+    }
+    
+    await Promise.all(tasks);
  }

+  /**
+   * Calculates a hash of the served directory for cache busting
+   */
  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);
+    try {
+      const serveDirHash = await plugins.smartfile.fs.fileTreeToHash(this.options.serveDir, '**/*');
+      this.serveHash = serveDirHash;
+      console.log('Current ServeDir hash: ' + serveDirHash);
+      this.serveDirHashSubject.next(serveDirHash);
+    } catch (error) {
+      console.error('Failed to create serve directory hash:', error);
+      // Use a timestamp-based hash as fallback
+      const fallbackHash = Date.now().toString(16).slice(-6);
+      this.serveHash = fallbackHash;
+      console.log('Using fallback hash: ' + fallbackHash);
+      this.serveDirHashSubject.next(fallbackHash);
+    }
  }
-}
+}
--- a/ts/servertools/classes.compressor.ts
+++ b/ts/servertools/classes.compressor.ts
@@ -111,6 +111,7 @@ export class Compressor {
    switch (method) {
      case 'gzip':
        compressionStream = plugins.zlib.createGzip();
+        return compressionStream;
      case 'br':
        compressionStream = plugins.zlib.createBrotliCompress({
          chunkSize: 16 * 1024,
@@ -118,10 +119,13 @@ export class Compressor {
            
          },
        });
+        return compressionStream;
      case 'deflate':
        compressionStream = plugins.zlib.createDeflate();
+        return compressionStream;
      default:
        compressionStream = plugins.smartstream.createPassThrough();
+        return compressionStream;
    }
  }
-}
+}
--- a/ts/servertools/classes.handlerproxy.ts
+++ b/ts/servertools/classes.handlerproxy.ts
@@ -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)
+        // 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: Buffer = proxiedResponse.body;
-      if (typeof responseToSend !== 'string') {
-        console.log(proxyRequestUrl);
-        console.log(responseToSend);
-        throw new Error(`Proxied response is not a string, but ${typeof responseToSend}`);
+      // 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();
    });
  }
-}
+}
--- a/ts/servertools/classes.handlerstatic.ts
+++ b/ts/servertools/classes.handlerstatic.ts
@@ -36,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)
+        // 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';
--- a/ts/servertools/classes.server.ts
+++ b/ts/servertools/classes.server.ts
@@ -132,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) => {
--- a/ts/servertools/classes.sitemap.ts
+++ b/ts/servertools/classes.sitemap.ts
@@ -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);
  }
-}
+}
--- a/ts/servertools/tools.serviceworker.ts
+++ b/ts/servertools/tools.serviceworker.ts
@@ -38,7 +38,7 @@ export const addServiceWorkerRoute = (
  swVersionInfo = swDataFunc();

  // the basic stuff
-  typedserverInstance.server.addRoute('/serviceworker.*', serviceworkerHandler);
+  typedserverInstance.server.addRoute('/serviceworker/*splat', serviceworkerHandler);

  // the typed stuff
  const typedrouter = new plugins.typedrequest.TypedRouter();
--- a/ts/servertools/tools.sslredirect.ts
+++ b/ts/servertools/tools.sslredirect.ts
@@ -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);
    })
--- a/ts/utilityservers/classes.websiteserver.ts
+++ b/ts/utilityservers/classes.websiteserver.ts
@@ -92,7 +92,10 @@ export class UtilityWebsiteServer {
        }
        const fullOriginAssetUrl = `https://assetbroker.lossless.one/brandfiles/00general/${manifestAssetName}`;
        console.log(`Getting ${manifestAssetName} from ${fullOriginAssetUrl}`);
-        const dataBuffer: Buffer = (await plugins.smartrequest.getBinary(fullOriginAssetUrl)).body;
+        const smartRequest = plugins.smartrequest.SmartRequest.create();
+        const response = await smartRequest.url(fullOriginAssetUrl).get();
+        const arrayBuffer = await response.arrayBuffer();
+        const dataBuffer: Buffer = Buffer.from(arrayBuffer);
        res.type('.png');
        res.write(dataBuffer);
        res.end();
--- a/ts_web_serviceworker/classes.backend.ts
+++ b/ts_web_serviceworker/classes.backend.ts
@@ -1,5 +1,40 @@
 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
@@ -34,7 +69,33 @@ export class ServiceworkerBackend {
   * 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)}`);
+    }
  }

  /**
@@ -44,10 +105,51 @@ export class ServiceworkerBackend {
    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)}`);
+    }
  }
 }
--- a/ts_web_serviceworker/classes.cachemanager.ts
+++ b/ts_web_serviceworker/classes.cachemanager.ts
@@ -15,211 +15,251 @@ export class CacheManager {
    this._setupCache();
  }

+  /**
+   * Sets up the service worker's fetch event to intercept and cache responses.
+   */
  private _setupCache = () => {
-    const createMatchRequest = (requestArg: Request) => {
-      // lets create a matchRequest
+    // 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;
-      if (requestArg.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin)) {
-        // internal request
-        matchRequest = requestArg;
-      } else {
-        matchRequest = new Request(requestArg.url, {
-          ...requestArg.clone(),
-          mode: 'cors'
-        });
+      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 response
+     * Creates a 500 error response.
     */
-    const create500Response = async (requestArg: Request, responseArg: Response) => {
-      return new Response(
-        `
-        <html>
-          <head>
-            <style>
-              .note {
-                padding: 10px;
-                color: #fff;
-                background: #000;
-                border-bottom: 1px solid #e4002b;
-                margin-bottom: 20px;
-              }
-            </style>
-          </head>
-          <body>
-          
-          <div class="note">
-            <strong>serviceworker running, but status 500</strong><br>
-          </div>
-          serviceworker is unable to fetch this request<br>
-          Here is some info about the request/response pair:<br>
-          <br>
-          requestUrl: ${requestArg.url}<br>
-          responseType: ${responseArg.type}<br>
-          responseBody: ${await responseArg.clone().text()}<br>
-          </body>
-        </html>
-      `,
-        {
-          headers: {
-            "Content-Type": "text/html"
-          },
-          status: 500
-        }
-      );
-    };
-  
-    // A list of local resources we always want to be cached.
-    this.losslessServiceWorkerRef.serviceWindowRef.addEventListener('fetch', async (fetchEventArg: any) => {
-      // Lets block scopes we don't want to be passing through the serviceworker
-      const originalRequest: Request = fetchEventArg.request;
-      const parsedUrl = new URL(originalRequest.url);
-      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;
+    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 });
      }
-      
-      // lets continue for the rest
-      const done = plugins.smartpromise.defer<Response>();
-      fetchEventArg.respondWith(done.promise);
-  
-      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://assetbroker.') ||
-        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')
-      ) {
-  
-        // lets see if things need to be updated
-        // not waiting here
-        this.losslessServiceWorkerRef.updateManager.checkUpdate(this);
-  
-        // this code block is executed for local requests
-        const matchRequest = createMatchRequest(originalRequest);
-        const cachedResponse = await caches.match(matchRequest);
-        if (cachedResponse) {
-          logger.log('ok', `CACHED: found cached response for ${matchRequest.url}`);
-          done.resolve(cachedResponse);
+    };
+
+    // 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;
        }
-  
-        // in case there is no cached response
-        logger.log('info', `NOTYETCACHED: trying to cache ${matchRequest.url}`);
-        const newResponse: Response = await fetch(matchRequest).catch(async err => {
-          return await create500Response(matchRequest, new Response(err.message));
-        });
-  
-        // fill cache
-        // Put a copy of the response in the runtime cache.
-        if (newResponse.status > 299 || newResponse.type === 'opaque') {
-          logger.log(
-            'error',
-            `NOTCACHED: can't cache response for ${matchRequest.url} due to status ${
-              newResponse.status
-            } and type ${newResponse.type}`
-          );
-          done.resolve(await create500Response(matchRequest, newResponse));
-        } else {
-          const cache = await caches.open(this.usedCacheNames.runtimeCacheName);
-          const responseToPutToCache = newResponse.clone();
-          const headers = new Headers();
-          responseToPutToCache.headers.forEach((value, key) => {
-            if (
-              value !== 'Cache-Control'
-              && value !== 'cache-control'
-              && value !== 'Expires'
-              && value !== 'expires'
-              && value !== 'Pragma'
-              && value !== 'pragma'
-            ) {
-              headers.set(key, value);
+
+        // 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));
            }
-          });
-          headers.set('Cache-Control', 'no-cache, no-store, must-revalidate');
-          headers.set('Pragma', 'no-cache');
-          headers.set('Expires', '0');
-          await cache.put(matchRequest, new Response(responseToPutToCache.body, {
-            ...responseToPutToCache,
-            headers
-          }));
-          logger.log(
-            'ok',
-            `NOWCACHED: cached response for ${matchRequest.url} for subsequent requests!`
-          );
-          done.resolve(newResponse);
+          }
+        } else {
+          // 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)));
+          }
        }
-      } else {
-        // this code block is executed for remote requests
-        logger.log(
-          'ok',
-          `NOTCACHED: not caching any responses for ${
-            originalRequest.url
-          }. Fetching from origin now...`
-        );
-        done.resolve(
-          await fetch(originalRequest).catch(async err => {
-            return await create500Response(originalRequest, new Response(err.message));
-          })
-        );
+      } catch (err) {
+        logger.log('error', `Unhandled fetch event error: ${err}`);
      }
    });
-  }
+  };

  /**
-   * update caches
-   * @param reasonArg
+   * Cleans all caches.
+   * Should only be run when a new ServiceWorker is activated.
   */
-
-  /**
-   * cleans all caches
-   * should only be run when running a new service worker
-   * @param reasonArg
-   */
-  public cleanCaches = async (reasonArg = 'no reason given') => {
-    logger.log('info', `MAJOR CACHEEVENT: cleaning caches now! Reason: ${reasonArg}`);
-    const cacheNames = await caches.keys();
-    
-    const deletePromises = cacheNames.map(cacheToDelete => {
-        const deletePromise = caches.delete(cacheToDelete);
-        deletePromise.then(() => {
+  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}`);
-        });
-        return deletePromise;
-      });
-    await Promise.all(deletePromises);
-  }
+        })
+      );
+      await Promise.all(deletePromises);
+    } catch (err) {
+      logger.log('error', `Error cleaning caches: ${err}`);
+    }
+  };

  /**
-   * revalidate cache
+   * Revalidates the runtime cache by fetching fresh responses and updating the cache.
   */
-  public async revalidateCache() {
-    const runtimeCache = await caches.open(this.usedCacheNames.runtimeCacheName);
-    const cacheKeys = await runtimeCache.keys();
-    for (const requestArg of cacheKeys) {
-      const cachedResponse = runtimeCache.match(requestArg);
-
-      // lets get a new response for comparison
-      const clonedRequest = requestArg.clone();
-      const response = await plugins.smartpromise.timeoutWrap(fetch(clonedRequest), 1000);
-      if (response && response.status >= 200 && response.status < 300) {
-        await runtimeCache.delete(requestArg);
-        await runtimeCache.put(requestArg, response);
+  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}`);
    }
  }
-}
+}
--- a/ts_web_serviceworker/classes.networkmanager.ts
+++ b/ts_web_serviceworker/classes.networkmanager.ts
@@ -1,18 +1,37 @@
 import * as plugins from './plugins.js';
 import { ServiceWorker } from './classes.serviceworker.js';
+import { logger } from './logging.js';

 export class NetworkManager {
  public serviceWorkerRef: ServiceWorker;
  public webRequest: plugins.webrequest.WebRequest;
+  private isOffline: boolean = false;
+  private lastOnlineCheck: number = 0;
+  private readonly ONLINE_CHECK_INTERVAL = 30000; // 30 seconds

  public previousState: string;

  constructor(serviceWorkerRefArg: ServiceWorker) {
    this.serviceWorkerRef = serviceWorkerRefArg;
    this.webRequest = new plugins.webrequest.WebRequest();
+    
+    // Listen for connection changes
    this.getConnection()?.addEventListener('change', () => {
      this.updateConnectionStatus();
    });
+
+    // Listen for online/offline events
+    self.addEventListener('online', () => {
+      this.isOffline = false;
+      logger.log('info', 'Device is now online');
+      this.updateConnectionStatus();
+    });
+
+    self.addEventListener('offline', () => {
+      this.isOffline = true;
+      logger.log('warn', 'Device is now offline');
+      this.updateConnectionStatus();
+    });
  }

  /**
@@ -28,6 +47,105 @@ export class NetworkManager {
  }

  public updateConnectionStatus() {
-    console.log(`Connection type changed from ${this.previousState} to ${this.getEffectiveType()}`);
+    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;
+  }
+}
--- a/ts_web_serviceworker/classes.serviceworker.ts
+++ b/ts_web_serviceworker/classes.serviceworker.ts
@@ -57,10 +57,15 @@ export class ServiceWorker {
      const done = new Deferred();
      event.waitUntil(done.promise);
      // its important to not go async before event.waitUntil
-      done.resolve();
-      logger.log('success', `service worker installed! TimeStamp = ${new Date().toISOString()}`);
-      selfArg.skipWaiting();
-      logger.log('note', `Called skip waiting!`);
+      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) => {
@@ -68,9 +73,19 @@ export class ServiceWorker {
      event.waitUntil(done.promise);

      // its important to not go async before event.waitUntil
-      await selfArg.clients.claim();
-      await this.cacheManager.cleanCaches('new service worker loaded! :)');
-      done.resolve();
+      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);
+      }
    });
  }
-}
+}
--- a/ts_web_serviceworker/classes.updatemanager.ts
+++ b/ts_web_serviceworker/classes.updatemanager.ts
@@ -17,24 +17,55 @@ export class UpdateManager {
  /**
   * 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))
-    ) {
+    } 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;
-    if (millisSinceLastCheck < 100000) {
-      // TODO account for being offline
+    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...');
@@ -49,9 +80,17 @@ export class UpdateManager {
      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);
    }
  }

@@ -59,17 +98,44 @@ export class UpdateManager {
   * gets the apphash from the server
   */
  public async getVersionInfoFromServer() {
-    const getAppHashRequest = new plugins.typedrequest.TypedRequest<
-      interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo
-    >('/sw-typedrequest', 'serviceworker_versionInfo');
-    const result = await getAppHashRequest.fire({});
-    return result;
+    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 () => {
Author	SHA1	Message	Date
Juergen Kunz	43d8aea4e1	3.0.78 Some checks failed Default (tags) / security (push) Failing after 22s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-09-03 12:33:04 +00:00
Juergen Kunz	776d6fb95d	fix(servertools): Fix wildcard path extraction for static/proxy handlers, correct serviceworker route, add local settings and test typo fix	2025-09-03 12:33:04 +00:00
Juergen Kunz	0f22c91499	3.0.77 Some checks failed Default (tags) / security (push) Failing after 22s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-08-17 12:49:28 +00:00
Juergen Kunz	a0f714a561	fix(servertools): Adjust route wildcard patterns and CORS handling; update serviceworker and SSL redirect patterns; bump express dependency; add local Claude settings	2025-08-17 12:49:28 +00:00
Juergen Kunz	9477eac268	3.0.76 Some checks failed Default (tags) / security (push) Failing after 23s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-08-17 08:14:08 +00:00
Juergen Kunz	8cbae75ae4	fix(handlerproxy): Use SmartRequest API and improve proxy/asset response handling; update tests and bump dependencies; add local project configuration files	2025-08-17 08:14:08 +00:00
Juergen Kunz	db05fc91c4	3.0.75 Some checks failed Default (tags) / security (push) Failing after 23s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-08-16 19:57:31 +00:00
Juergen Kunz	6e647a3556	fix(deps): Update dependencies, test tooling and test imports; enhance npm test script	2025-08-16 19:57:30 +00:00
Philipp Kunz	6da22ab607	3.0.74 Some checks failed Default (tags) / security (push) Failing after 9s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-12 14:36:59 +00:00
Philipp Kunz	fb98b3294a	fix(commit-info): chore: update commit metadata (no source code changes)	2025-04-12 14:36:59 +00:00
Philipp Kunz	848ef1d3d1	3.0.73 Some checks failed Default (tags) / security (push) Failing after 17s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-11 10:59:09 +00:00
Philipp Kunz	497b267b43	fix(metadata): Update repository URLs and metadata to reflect the new organization scope	2025-04-11 10:59:09 +00:00
Philipp Kunz	d5875d5031	3.0.72 Some checks failed Default (tags) / security (push) Failing after 9s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-11 09:47:37 +00:00
Philipp Kunz	b06c67ebac	fix(project): chore: no changes - commit metadata update	2025-04-11 09:47:37 +00:00
Philipp Kunz	3d7e5c439d	3.0.71 Some checks failed Default (tags) / security (push) Failing after 19s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-11 09:45:41 +00:00
Philipp Kunz	84f7d8d4a0	fix(serviceworker): Improve error handling and logging in service worker backend and network manager; update multiple dependency versions and packageManager settings.	2025-04-11 09:45:41 +00:00
Philipp Kunz	42e8e575d8	3.0.70	2025-03-16 12:02:49 +00:00
Philipp Kunz	d5f7fbbb9a	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.	2025-03-16 12:02:49 +00:00
Philipp Kunz	0dcb9edcbe	3.0.69	2025-03-16 11:53:58 +00:00
Philipp Kunz	85ca50fc8b	fix(servertools): Fix compression stream creation returns, handler proxy buffer conversion, and sitemap URL concatenation	2025-03-16 11:53:57 +00:00
Philipp Kunz	b3726cb518	3.0.68	2025-02-07 12:55:48 +01:00
Philipp Kunz	ec6754be52	fix(cache-manager): Simplify cache control headers in cache manager	2025-02-07 12:55:47 +01:00
Philipp Kunz	1ced20c887	3.0.67	2025-02-06 21:13:54 +01:00
Philipp Kunz	3556594501	fix(serviceworker): Enhance header security for cached resources in service worker	2025-02-06 21:13:53 +01:00
Philipp Kunz	dd6babdf81	3.0.66	2025-02-06 02:54:37 +01:00
Philipp Kunz	75ce27a4bf	fix(serviceworker): Improve error handling and logging in cache manager and update manager.	2025-02-06 02:54:37 +01:00
Philipp Kunz	435a4a0349	3.0.65	2025-02-04 17:09:49 +01:00
Philipp Kunz	b1983edcd7	fix(readme): Update documentation with advanced usage and examples	2025-02-04 17:09:49 +01:00
Philipp Kunz	1a9c656f2e	3.0.64	2025-02-04 13:01:31 +01:00
Philipp Kunz	569fa4fc46	fix(serviceworker): Improve cache handling and response header management in service worker.	2025-02-04 13:01:30 +01:00
Philipp Kunz	cbb10d7c19	3.0.63	2025-02-04 01:58:48 +01:00
Philipp Kunz	ab4c302cea	fix(core): Refactored caching strategy for service worker to improve compatibility and performance.	2025-02-04 01:58:48 +01:00
Philipp Kunz	0017a559ca	3.0.62	2025-02-04 01:52:48 +01:00
Philipp Kunz	270230b0ca	fix(Service Worker): Refactor and clean up the cache logic in the Service Worker to improve maintainability and handle Safari-specific cache behavior.	2025-02-04 01:52:48 +01:00
Philipp Kunz	6cedd53d61	3.0.61	2025-02-04 01:45:09 +01:00
Philipp Kunz	f518300d68	fix(ServiceWorkerCacheManager): fixed caching	2025-02-04 01:45:08 +01:00
Philipp Kunz	8f6f177d19	3.0.60	2025-02-04 01:36:36 +01:00
Philipp Kunz	4e560a9a51	fix(cachemanager): Improve cache management and error handling	2025-02-04 01:36:35 +01:00
Philipp Kunz	7999e370f6	3.0.59	2025-02-03 23:26:09 +01:00
Philipp Kunz	efade7a78e	fix(serviceworker): Fixed CORS and Cache Control handling for Service Worker	2025-02-03 23:26:08 +01:00
Philipp Kunz	0fecf69420	3.0.58	2025-02-03 00:30:18 +01:00
Philipp Kunz	804537c059	fix(network-manager): Refined network management logic for better offline handling.	2025-02-03 00:30:18 +01:00
Philipp Kunz	aebcbe4a61	3.0.57	2025-02-03 00:25:06 +01:00
Philipp Kunz	c5cb8c1f01	fix(updateManager): Refine cache management for service worker updates.	2025-02-03 00:25:05 +01:00
Philipp Kunz	8202ce6227	3.0.56	2025-02-03 00:16:59 +01:00
Philipp Kunz	4598bd0e25	fix(cachemanager): Adjust cache control headers and fix redundant code	2025-02-03 00:16:58 +01:00
Philipp Kunz	021c980a4f	3.0.55	2025-01-28 10:53:43 +01:00
Philipp Kunz	c7dca75827	fix(server): Fix response content manipulation for HTML files with injectReload	2025-01-28 10:53:42 +01:00