3.0.74

changelog.md

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

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.65",
+  "version": "3.0.74",
   "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
   "type": "module",
   "exports": {
@@ -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,19 +56,19 @@
     "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.20250410.0",
     "@design.estate/dees-comms": "^1.0.27",
     "@push.rocks/lik": "^6.1.0",
     "@push.rocks/smartchok": "^1.0.34",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartenv": "^5.0.12",
     "@push.rocks/smartfeed": "^1.0.11",
-    "@push.rocks/smartfile": "^11.0.23",
+    "@push.rocks/smartfile": "^11.2.0",
     "@push.rocks/smartjson": "^5.0.20",
     "@push.rocks/smartlog": "^3.0.7",
     "@push.rocks/smartlog-destination-devtools": "^1.0.12",
@@ -79,8 +79,8 @@
     "@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/smartpromise": "^4.2.3",
+    "@push.rocks/smartrequest": "^2.1.0",
     "@push.rocks/smartrx": "^3.0.7",
     "@push.rocks/smartsitemap": "^2.0.3",
     "@push.rocks/smartstream": "^3.2.5",
@@ -88,8 +88,8 @@
     "@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",
+    "@tsclass/tsclass": "^8.2.0",
+    "@types/express": "^5.0.1",
     "body-parser": "^1.20.3",
     "cors": "^2.8.5",
     "express": "^4.21.2",
@@ -97,15 +97,16 @@
     "lit": "^3.2.1"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.2.0",
-    "@git.zone/tsbundle": "^2.1.0",
+    "@git.zone/tsbuild": "^2.3.2",
+    "@git.zone/tsbundle": "^2.2.5",
     "@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": "^1.0.96",
+    "@push.rocks/tapbundle": "^5.6.3",
+    "@types/node": "^22.14.0"
   },
   "private": false,
   "browserslist": [
     "last 1 chrome versions"
-  ]
+  ],
+  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6"
 }

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@api.global/typedserver',
-  version: '3.0.65',
+  version: '3.0.74',
   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,19 +118,32 @@ 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(
         '/*',
@@ -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.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;
     }
   }
-}
+}

ts/servertools/classes.handlerproxy.ts

@@ -40,11 +40,21 @@ 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}`);
+      // Ensure body exists and convert it to Buffer consistently
+      let responseToSend: Buffer;
+      
+      if (proxiedResponse.body !== undefined && proxiedResponse.body !== null) {
+        if (Buffer.isBuffer(proxiedResponse.body)) {
+          responseToSend = proxiedResponse.body;
+        } else if (typeof proxiedResponse.body === 'string') {
+          responseToSend = Buffer.from(proxiedResponse.body);
+        } else {
+          // Handle other types (like objects) by JSON stringifying them
+          responseToSend = Buffer.from(JSON.stringify(proxiedResponse.body));
+        }
+      } else {
+        // Provide a default empty buffer if body is undefined/null
+        responseToSend = Buffer.from('');
       }
 
       if (optionsArg && optionsArg.responseModifier) {
@@ -74,4 +84,4 @@ export class HandlerProxy extends Handler {
       res.end();
     });
   }
-}
+}

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

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.cachemanager.ts

@@ -15,22 +15,34 @@ export class CacheManager {
     this._setupCache();
   }
 
+  /**
+   * Sets up the service worker's fetch event to intercept and cache responses.
+   */
   private _setupCache = () => {
+    // Create a matching request. For internal requests, reuse the original; for external requests, create one with CORS settings.
     const createMatchRequest = (requestArg: Request): Request => {
-      // Create a matchRequest based on whether the request is internal or external.
       let matchRequest: Request;
-      if (requestArg.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin)) {
-        // Internal request; use the original.
-        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'
-        });
+      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;
     };
@@ -39,192 +51,215 @@ export class CacheManager {
      * Creates a 500 error response.
      */
     const create500Response = async (requestArg: Request, responseArg: Response): Promise<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
-        }
-      );
+      try {
+        const responseText = await responseArg.clone().text();
+        return new Response(
+          `
+          <html>
+            <head>
+              <style>
+                .note {
+                  padding: 10px;
+                  color: #fff;
+                  background: #000;
+                  border-bottom: 1px solid #e4002b;
+                  margin-bottom: 20px;
+                }
+              </style>
+            </head>
+            <body>
+              <div class="note">
+                <strong>ServiceWorker error 500</strong><br>
+              </div>
+              ServiceWorker is unable to fetch this request.<br>
+              <br>
+              <strong>Request URL:</strong> ${requestArg.url}<br>
+              <strong>Response Type:</strong> ${responseArg.type}<br>
+              <strong>Response Body:</strong> ${responseText}<br>
+            </body>
+          </html>
+        `,
+          {
+            headers: { 'Content-Type': 'text/html' },
+            status: 500
+          }
+        );
+      } catch (err) {
+        logger.log('error', `Error creating 500 response for ${requestArg.url}: ${err}`);
+        return new Response('Internal error', { status: 500 });
+      }
     };
 
-    // Listen for fetch events.
+    // Listen for fetch events on the service worker's controlled window.
     this.losslessServiceWorkerRef.serviceWindowRef.addEventListener('fetch', async (fetchEventArg: any) => {
-      // Block specific scopes.
-      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;
-      }
+      try {
+        const originalRequest: Request = fetchEventArg.request;
+        const parsedUrl = new URL(originalRequest.url);
 
-      // Create a deferred response.
-      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://unpkg.com') ||
-        originalRequest.url.includes('https://fonts.googleapis.com') ||
-        originalRequest.url.includes('https://fonts.gstatic.com')
-      ) {
-        // Check for updates asynchronously.
-        this.losslessServiceWorkerRef.updateManager.checkUpdate(this);
-
-        // Try to serve from cache.
-        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);
+        // 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, fetch from the network.
-        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));
-        });
+        // Create a deferred promise for the fetch event's response.
+        const done = plugins.smartpromise.defer<Response>();
+        fetchEventArg.respondWith(done.promise);
 
-        // If the response status is an error or the response is opaque, do not cache it.
-        if (newResponse.status > 299 || newResponse.type === 'opaque' || (newResponse.headers.get('access-control-allow-origin') === null && !matchRequest.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin))) {
-          logger.log(
-            'error',
-            `NOTCACHED: not caching response for ${matchRequest.url} due to status ${newResponse.status} and type ${newResponse.type}`
-          );
-          // Simply return the network response without caching.
-          done.resolve(newResponse);
-          return;
-        } else {
-          // Cache the response.
-          const cache = await caches.open(this.usedCacheNames.runtimeCacheName);
-          const responseToPutToCache = newResponse.clone();
-          const headers = new Headers();
-          responseToPutToCache.headers.forEach((value, key) => {
-            // Preserve all headers except caching-related ones.
-            if (![
-              'Cache-Control',
-              'cache-control',
-              'Expires',
-              'expires',
-              'Pragma',
-              'pragma'
-            ].includes(key)) {
-              headers.set(key, value);
+        // 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));
             }
-          });
-
-          // Ensure CORS headers are present.
-          if (!headers.has('Access-Control-Allow-Origin')) {
-            headers.set('Access-Control-Allow-Origin', '*');
           }
-          headers.set('Vary', 'Origin');
-          if (!headers.has('Access-Control-Expose-Headers')) {
-            headers.set('Access-Control-Expose-Headers', '*')
+        } 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)));
           }
-          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');
-          }
-          // Prevent browser caching while allowing service worker caching.
-          headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
-          headers.set('Pragma', 'no-cache');
-          headers.set('Expires', '0');
-          headers.set('Surrogate-Control', 'no-store');
-
-          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 remote requests not intended for caching, fetch directly from the origin.
-        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}`);
       }
     });
-  }
+  };
 
   /**
    * Cleans all caches.
-   * Should only be run when a new service worker is activated.
+   * Should only be run when a new ServiceWorker is activated.
    */
-  public cleanCaches = async (reasonArg = 'no reason given') => {
-    logger.log('info', `MAJOR CACHEEVENT: cleaning caches now! Reason: ${reasonArg}`);
-    const cacheNames = await caches.keys();
-
-    const deletePromises = cacheNames.map(cacheToDelete => {
-      const deletePromise = caches.delete(cacheToDelete);
-      deletePromise.then(() => {
-        logger.log('ok', `Deleted cache ${cacheToDelete}`);
-      });
-      return deletePromise;
-    });
-    await Promise.all(deletePromises);
-  }
+  public cleanCaches = async (reasonArg = 'no reason given'): Promise<void> => {
+    try {
+      logger.log('info', `MAJOR CACHEEVENT: Cleaning caches now! Reason: ${reasonArg}`);
+      const cacheNames = await caches.keys();
+      const deletePromises = cacheNames.map((cacheToDelete) =>
+        caches.delete(cacheToDelete).then(() => {
+          logger.log('ok', `Deleted cache ${cacheToDelete}`);
+        })
+      );
+      await Promise.all(deletePromises);
+    } catch (err) {
+      logger.log('error', `Error cleaning caches: ${err}`);
+    }
+  };
 
   /**
-   * Revalidates the runtime cache.
+   * 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) {
-      // Fetch a new response for comparison.
-      const clonedRequest = requestArg.clone();
-      const response = await plugins.smartpromise.timeoutWrap(fetch(clonedRequest), 5000); // Increased timeout for better mobile compatibility
-      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}`);
     }
   }
 }

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

ts_web_serviceworker/classes.updatemanager.ts

@@ -104,14 +104,9 @@ export class UpdateManager {
       >('/sw-typedrequest', 'serviceworker_versionInfo');
       
       // Use networkManager for the request with retries and timeout
-      const response = await this.serviceworkerRef.networkManager.makeRequest('/sw-typedrequest', {
-        timeoutMs: 5000,
-        retries: 2,
-        backoffMs: 1000
-      });
-      
-      const result = await response.json();
-      return result;
+      const response = await getAppHashRequest.fire({});
+
+      return response;
     } catch (error) {
       logger.log('warn', `Failed to get version info from server: ${error.message}`);
       throw error;