v3.0.80

.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

@@ -1,5 +1,100 @@
 # Changelog
 
+## 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
 

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",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@api.global/typedserver",
-  "version": "3.0.69",
+  "version": "3.0.80",
   "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/smartfeed": "^1.0.11",
-    "@push.rocks/smartfile": "^11.0.23",
-    "@push.rocks/smartjson": "^5.0.20",
-    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartenv": "^5.0.13",
+    "@push.rocks/smartfeed": "^1.4.0",
+    "@push.rocks/smartfile": "^11.2.7",
+    "@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",
@@ -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/smartsitemap": "^2.0.3",
+    "@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.4",
     "@push.rocks/smartstream": "^3.2.5",
     "@push.rocks/smarttime": "^4.1.1",
-    "@push.rocks/taskbuffer": "^3.1.7",
+    "@push.rocks/taskbuffer": "^3.4.0",
     "@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.3.0",
+    "@types/express": "^5.0.5",
+    "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/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.90",
-    "@push.rocks/tapbundle": "^5.5.3",
-    "@types/node": "^22.10.2"
+    "@git.zone/tsbuild": "^3.1.0",
+    "@git.zone/tsbundle": "^2.5.2",
+    "@git.zone/tsrun": "^2.0.0",
+    "@git.zone/tstest": "^2.8.2",
+    "@types/node": "^22.14.0"
   },
   "private": false,
   "browserslist": [
     "last 1 chrome versions"
-  ]
+  ],
+  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6"
 }

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

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@api.global/typedserver',
-  version: '3.0.69',
+  version: '3.0.80',
   description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }

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,22 +118,35 @@ 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) => {
             if (plugins.path.parse(responseArg.path).ext === '.html') {
@@ -154,7 +168,7 @@ export class TypedServer {
                 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;
@@ -166,6 +180,7 @@ export class TypedServer {
               headers,
               path: responseArg.path,
               responseContent: responseArg.responseContent,
+              travelData: responseArg.travelData,
             };
           },
           serveIndexHtmlDefault: true,
@@ -173,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
+    }
   }
 
   /**
@@ -214,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);
+    }
   }
-}
+}

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 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,12 +86,20 @@ export class HandlerProxy extends Handler {
         }
       }
 
-      let responseToSend: Buffer = proxiedResponse.body;
-      
-      // Remove incorrect type check that expects responseToSend to be a string
-      // Instead, ensure it's a Buffer for consistent handling
-      if (!Buffer.isBuffer(responseToSend)) {
-        responseToSend = Buffer.from(responseToSend.toString());
+      // 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) {

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

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) => {

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

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

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

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

ts_web_serviceworker/classes.networkmanager.ts

@@ -96,32 +96,56 @@ export class NetworkManager {
       backoffMs = 1000
     } = options;
 
-    let lastError: Error;
+    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');
         }
 
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        // 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) {
-          await new Promise(resolve => setTimeout(resolve, backoffMs * (i + 1)));
+          const backoffTime = backoffMs * (i + 1);
+          logger.log('info', `Retrying in ${backoffTime}ms...`);
+          await new Promise(resolve => setTimeout(resolve, backoffTime));
         }
       }
     }
 
-    throw lastError;
+    // 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

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