v6.7.0

changelog.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 2025-12-04 - 6.7.0 - feat(web_serviceworker)
+Add per-resource metrics and request deduplication to service worker cache manager
+
+- Introduce per-resource tracking in metrics: ICachedResource, IDomainStats, IContentTypeStats and a resourceStats map.
+- Add MetricsCollector.recordResourceAccess(...) to record hits/misses, content-type and size; provide getters: getCachedResources, getDomainStats, getContentTypeStats and getResourceCount.
+- Reset resourceStats when metrics are reset and limit resource entries via cleanupResourceStats to avoid memory bloat.
+- Add request deduplication in CacheManager (fetchWithDeduplication) to coalesce identical concurrent fetches and a periodic safety cleanup for in-flight requests.
+- Record resource accesses on cache hit and when storing new cache entries (captures content-type and body size).
+- Expose a dashboard resources endpoint (/sw-dash/resources) served by the SW dashboard to return detailed resource data for SPA views.
+
+## 2025-12-04 - 6.6.0 - feat(web_serviceworker)
+Enable service worker dashboard speedtests via TypedSocket, expose ServiceWorker instance to dashboard, and add server-side speedtest handler
+
+- Add `serviceworker_speedtest` typed handler in TypedServer to support download/upload/latency tests from service workers
+- Export `getServiceWorkerInstance` from the web_serviceworker entrypoint so other modules (dashboard) can access the running ServiceWorker instance
+- Make ServiceWorker.typedsocket and ServiceWorker.typedrouter public to allow the dashboard to create and fire TypedSocket requests
+- Update dashboard to run latency, download and upload tests over TypedSocket instead of POSTing to /sw-typedrequest
+- Deprecate legacy servertools.Server.addTypedSocket (now a no-op) and recommend using TypedServer with SmartServe integration for WebSocket support
+
+## 2025-12-04 - 6.5.0 - feat(serviceworker)
+Add server-driven service worker cache invalidation and TypedSocket integration
+
+- TypedServer: push cache invalidation messages to service worker clients (tagged 'serviceworker') before notifying frontend clients on reload
+- Service Worker: connect to TypedServer via TypedSocket; handle 'serviceworker_cacheInvalidate' typed request to clean caches and trigger client reloads
+- Web inject: add fallback to clear caches via the Cache API when global service worker helper is not available
+- Interfaces: add IRequest_Serviceworker_CacheInvalidate typedrequest interface
+- Plugins: export typedsocket in web_serviceworker plugin surface
+- Service worker connection: retry logic and improved logging for TypedSocket connection attempts
+
 ## 2025-12-04 - 6.4.0 - feat(serviceworker)
 Add speedtest support to service worker and dashboard
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@api.global/typedserver",
-  "version": "6.4.0",
+  "version": "6.7.0",
   "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
   "type": "module",
   "exports": {

ts/00_commitinfo_data.ts

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

ts/classes.typedserver.ts

@@ -306,6 +306,35 @@ export class TypedServer {
           };
         })
       );
+
+      // Speedtest handler for service worker dashboard
+      this.typedrouter.addTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Speedtest>(
+        new plugins.typedrequest.TypedHandler('serviceworker_speedtest', async (reqArg) => {
+          const startTime = Date.now();
+          const payloadSizeKB = reqArg.payloadSizeKB || 100;
+          const sizeBytes = payloadSizeKB * 1024;
+          let payload: string | undefined;
+          let bytesTransferred = 0;
+
+          switch (reqArg.type) {
+            case 'download':
+              payload = 'x'.repeat(sizeBytes);
+              bytesTransferred = sizeBytes;
+              break;
+            case 'upload':
+              bytesTransferred = reqArg.payload?.length || 0;
+              break;
+            case 'latency':
+              bytesTransferred = 1;
+              break;
+          }
+
+          const durationMs = Date.now() - startTime;
+          const speedMbps = durationMs > 0 ? (bytesTransferred * 8) / (durationMs * 1000) : 0;
+
+          return { durationMs, bytesTransferred, speedMbps, timestamp: Date.now(), payload };
+        })
+      );
     } catch (error) {
       console.error('Failed to initialize TypedSocket:', error);
     }
@@ -500,6 +529,30 @@ export class TypedServer {
       return;
     }
 
+    // Push cache invalidation to service workers first
+    try {
+      const swConnections = await this.typedsocket.findAllTargetConnectionsByTag('serviceworker');
+      for (const connection of swConnections) {
+        const pushCacheInvalidate =
+          this.typedsocket.createTypedRequest<interfaces.serviceworker.IRequest_Serviceworker_CacheInvalidate>(
+            'serviceworker_cacheInvalidate',
+            connection
+          );
+        pushCacheInvalidate.fire({
+          reason: 'File change detected',
+          timestamp: this.lastReload,
+        }).catch(err => {
+          console.warn('Failed to push cache invalidation to service worker:', err);
+        });
+      }
+      if (swConnections.length > 0) {
+        console.log(`Pushed cache invalidation to ${swConnections.length} service worker(s)`);
+      }
+    } catch (error) {
+      console.warn('Failed to notify service workers:', error);
+    }
+
+    // Notify frontend clients
     try {
       const connections = await this.typedsocket.findAllTargetConnectionsByTag(
         'typedserver_frontend'

ts_interfaces/serviceworker.ts

@@ -195,6 +195,24 @@ export interface IConnectionResult {
 // Speedtest interfaces
 // ===============
 
+/**
+ * Cache invalidation request from server to service worker
+ */
+export interface IRequest_Serviceworker_CacheInvalidate
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_CacheInvalidate
+  > {
+  method: 'serviceworker_cacheInvalidate';
+  request: {
+    reason: string;
+    timestamp: number;
+  };
+  response: {
+    success: boolean;
+  };
+}
+
 /**
  * Speedtest request between service worker and backend
  */

ts_web_inject/index.ts

@@ -75,8 +75,17 @@ export class ReloadChecker {
       this.infoscreen.setText(reloadText);
       if (globalThis.globalSw?.purgeCache) {
         await globalThis.globalSw.purgeCache();
+      } else if ('caches' in window) {
+        // Fallback: clear caches via Cache API when service worker client isn't initialized
+        try {
+          const cacheKeys = await caches.keys();
+          await Promise.all(cacheKeys.map(key => caches.delete(key)));
+          logger.log('ok', 'Cleared caches via Cache API fallback');
+        } catch (err) {
+          logger.log('warn', `Failed to clear caches via Cache API: ${err}`);
+        }
       } else {
-        console.log('globalThis.globalSw not found...');
+        console.log('globalThis.globalSw not found and Cache API not available...');
       }
       this.infoscreen.setText(`cleaned caches`);
       await plugins.smartdelay.delayFor(200);

ts_web_serviceworker/classes.cachemanager.ts

@@ -220,6 +220,11 @@ export class CacheManager {
           fetchEventArg.respondWith(dashboard.runSpeedtest());
           return;
         }
+        if (parsedUrl.pathname === '/sw-dash/resources') {
+          const dashboard = getDashboardGenerator();
+          fetchEventArg.respondWith(Promise.resolve(dashboard.serveResources()));
+          return;
+        }
 
         // Block requests that we don't want the service worker to handle.
         if (
@@ -260,7 +265,9 @@ export class CacheManager {
             // Record cache hit
             const contentLength = cachedResponse.headers.get('content-length');
             const bytes = contentLength ? parseInt(contentLength, 10) : 0;
+            const contentType = cachedResponse.headers.get('content-type') || 'unknown';
             metrics.recordCacheHit(matchRequest.url, bytes);
+            metrics.recordResourceAccess(matchRequest.url, true, contentType, bytes);
             eventBus.emitCacheHit(matchRequest.url, bytes);
 
             logger.log('ok', `CACHED: Found cached response for ${matchRequest.url}`);
@@ -335,6 +342,12 @@ export class CacheManager {
               });
 
               await cache.put(matchRequest, newCachedResponse);
+
+              // Record resource access for per-resource tracking
+              const cachedContentType = newResponse.headers.get('content-type') || 'unknown';
+              const cachedSize = bodyBlob.size;
+              metrics.recordResourceAccess(matchRequest.url, false, cachedContentType, cachedSize);
+
               logger.log('ok', `NOWCACHED: Cached response for ${matchRequest.url} for subsequent requests!`);
               done.resolve(newResponse);
             } catch (err) {

ts_web_serviceworker/classes.metrics.ts

@@ -12,6 +12,44 @@ export interface ICacheMetrics {
   averageResponseTime: number;
 }
 
+/**
+ * Interface for per-resource tracking
+ */
+export interface ICachedResource {
+  url: string;
+  domain: string;
+  contentType: string;
+  size: number;
+  hitCount: number;
+  missCount: number;
+  lastAccessed: number;
+  cachedAt: number;
+}
+
+/**
+ * Interface for domain statistics
+ */
+export interface IDomainStats {
+  domain: string;
+  totalResources: number;
+  totalSize: number;
+  totalHits: number;
+  totalMisses: number;
+  hitRate: number;
+}
+
+/**
+ * Interface for content-type statistics
+ */
+export interface IContentTypeStats {
+  contentType: string;
+  totalResources: number;
+  totalSize: number;
+  totalHits: number;
+  totalMisses: number;
+  hitRate: number;
+}
+
 /**
  * Interface for network metrics
  */
@@ -129,6 +167,10 @@ export class MetricsCollector {
   private readonly maxResponseTimeEntries = 1000;
   private readonly responseTimeWindow = 5 * 60 * 1000; // 5 minutes
 
+  // Per-resource tracking
+  private resourceStats: Map<string, ICachedResource> = new Map();
+  private readonly maxResourceEntries = 500;
+
   // Start time
   private readonly startTime: number;
 
@@ -441,6 +483,7 @@ export class MetricsCollector {
     // Note: isOnline is not reset as it reflects current state
 
     this.responseTimes = [];
+    this.resourceStats.clear();
 
     logger.log('info', '[Metrics] All metrics reset');
   }
@@ -457,6 +500,178 @@ export class MetricsCollector {
       `Uptime: ${Math.round(metrics.uptime / 1000)}s`,
     ].join(' | ');
   }
+
+  // ===================
+  // Per-Resource Tracking
+  // ===================
+
+  /**
+   * Extracts domain from URL
+   */
+  private extractDomain(url: string): string {
+    try {
+      const parsedUrl = new URL(url);
+      return parsedUrl.hostname;
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Records a resource access (cache hit or miss) with details
+   */
+  public recordResourceAccess(
+    url: string,
+    isHit: boolean,
+    contentType: string = 'unknown',
+    size: number = 0
+  ): void {
+    const now = Date.now();
+    const domain = this.extractDomain(url);
+
+    let resource = this.resourceStats.get(url);
+
+    if (!resource) {
+      resource = {
+        url,
+        domain,
+        contentType,
+        size,
+        hitCount: 0,
+        missCount: 0,
+        lastAccessed: now,
+        cachedAt: now,
+      };
+      this.resourceStats.set(url, resource);
+    }
+
+    // Update resource stats
+    if (isHit) {
+      resource.hitCount++;
+    } else {
+      resource.missCount++;
+    }
+    resource.lastAccessed = now;
+
+    // Update content-type and size if provided (may come from response headers)
+    if (contentType !== 'unknown') {
+      resource.contentType = contentType;
+    }
+    if (size > 0) {
+      resource.size = size;
+    }
+
+    // Trim old entries if needed
+    this.cleanupResourceStats();
+  }
+
+  /**
+   * Cleans up old resource entries to prevent memory bloat
+   */
+  private cleanupResourceStats(): void {
+    if (this.resourceStats.size <= this.maxResourceEntries) {
+      return;
+    }
+
+    // Convert to array and sort by lastAccessed (oldest first)
+    const entries = Array.from(this.resourceStats.entries())
+      .sort((a, b) => a[1].lastAccessed - b[1].lastAccessed);
+
+    // Remove oldest entries until we're under the limit
+    const toRemove = entries.slice(0, entries.length - this.maxResourceEntries);
+    for (const [url] of toRemove) {
+      this.resourceStats.delete(url);
+    }
+  }
+
+  /**
+   * Gets all cached resources
+   */
+  public getCachedResources(): ICachedResource[] {
+    return Array.from(this.resourceStats.values());
+  }
+
+  /**
+   * Gets domain statistics
+   */
+  public getDomainStats(): IDomainStats[] {
+    const domainMap = new Map<string, IDomainStats>();
+
+    for (const resource of this.resourceStats.values()) {
+      let stats = domainMap.get(resource.domain);
+
+      if (!stats) {
+        stats = {
+          domain: resource.domain,
+          totalResources: 0,
+          totalSize: 0,
+          totalHits: 0,
+          totalMisses: 0,
+          hitRate: 0,
+        };
+        domainMap.set(resource.domain, stats);
+      }
+
+      stats.totalResources++;
+      stats.totalSize += resource.size;
+      stats.totalHits += resource.hitCount;
+      stats.totalMisses += resource.missCount;
+    }
+
+    // Calculate hit rates
+    for (const stats of domainMap.values()) {
+      const total = stats.totalHits + stats.totalMisses;
+      stats.hitRate = total > 0 ? Math.round((stats.totalHits / total) * 100) : 0;
+    }
+
+    return Array.from(domainMap.values());
+  }
+
+  /**
+   * Gets content-type statistics
+   */
+  public getContentTypeStats(): IContentTypeStats[] {
+    const typeMap = new Map<string, IContentTypeStats>();
+
+    for (const resource of this.resourceStats.values()) {
+      // Normalize content-type (extract base type)
+      const baseType = resource.contentType.split(';')[0].trim() || 'unknown';
+
+      let stats = typeMap.get(baseType);
+
+      if (!stats) {
+        stats = {
+          contentType: baseType,
+          totalResources: 0,
+          totalSize: 0,
+          totalHits: 0,
+          totalMisses: 0,
+          hitRate: 0,
+        };
+        typeMap.set(baseType, stats);
+      }
+
+      stats.totalResources++;
+      stats.totalSize += resource.size;
+      stats.totalHits += resource.hitCount;
+      stats.totalMisses += resource.missCount;
+    }
+
+    // Calculate hit rates
+    for (const stats of typeMap.values()) {
+      const total = stats.totalHits + stats.totalMisses;
+      stats.hitRate = total > 0 ? Math.round((stats.totalHits / total) * 100) : 0;
+    }
+
+    return Array.from(typeMap.values());
+  }
+
+  /**
+   * Gets resource count
+   */
+  public getResourceCount(): number {
+    return this.resourceStats.size;
+  }
 }
 
 // Export singleton getter for convenience

ts_web_serviceworker/classes.serviceworker.ts

@@ -27,6 +27,10 @@ export class ServiceWorker {
   public taskManager: TaskManager;
   public store: plugins.webstore.WebStore;
 
+  // TypedSocket connection for server communication
+  public typedsocket: plugins.typedsocket.TypedSocket;
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
   constructor(selfArg: interfaces.ServiceWindow) {
     logger.log('info', `Service worker instantiating at ${Date.now()}`);
     this.serviceWindowRef = selfArg;
@@ -76,16 +80,52 @@ export class ServiceWorker {
       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()}`);
+
+        // Connect to TypedServer for cache invalidation after activation
+        this.connectToServer();
       } catch (error) {
         logger.log('error', `Service worker activation error: ${error}`);
         done.reject(error);
       }
     });
   }
+
+  /**
+   * Connect to TypedServer via TypedSocket for cache invalidation
+   */
+  private async connectToServer(): Promise<void> {
+    try {
+      // Register handler for cache invalidation from server
+      this.typedrouter.addTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_CacheInvalidate>(
+        new plugins.typedrequest.TypedHandler('serviceworker_cacheInvalidate', async (reqArg) => {
+          logger.log('info', `Cache invalidation requested from server: ${reqArg.reason}`);
+          await this.cacheManager.cleanCaches(reqArg.reason);
+          // Notify all clients to reload
+          await this.leleServiceWorkerBackend.triggerReloadAll();
+          return { success: true };
+        })
+      );
+
+      // Connect to server via TypedSocket
+      this.typedsocket = await plugins.typedsocket.TypedSocket.createClient(
+        this.typedrouter,
+        this.serviceWindowRef.location.origin
+      );
+
+      // Tag this connection as a service worker for server-side filtering
+      await this.typedsocket.setTag('serviceworker', {});
+
+      logger.log('ok', 'Service worker connected to TypedServer via TypedSocket');
+    } catch (error: any) {
+      logger.log('warn', `Service worker TypedSocket connection failed: ${error?.message || error}`);
+      // Retry connection after a delay
+      setTimeout(() => this.connectToServer(), 10000);
+    }
+  }
 }

ts_web_serviceworker/index.ts

@@ -5,3 +5,6 @@ declare var self: env.ServiceWindow;
 import { ServiceWorker } from './classes.serviceworker.js';
 
 const sw = new ServiceWorker(self);
+
+// Export getter for service worker instance (used by dashboard for TypedSocket access)
+export const getServiceWorkerInstance = (): ServiceWorker => sw;

ts_web_serviceworker/plugins.ts

@@ -5,8 +5,9 @@ export { interfaces };
 
 // @apiglobal scope
 import * as typedrequest from '@api.global/typedrequest';
+import * as typedsocket from '@api.global/typedsocket';
 
-export { typedrequest };
+export { typedrequest, typedsocket };
 
 // @pushrocks scope
 import * as smartdelay from '@push.rocks/smartdelay';