7.8.3

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

+## 2025-12-04 - 7.8.0 - feat(serviceworker)
+Add TypedRequest traffic monitoring and SW dashboard 'Requests' panel
+
+- Add TypedRequest traffic monitoring interfaces and shared SW dashboard HTML (SW_DASH_HTML) to ts_interfaces/serviceworker.ts.
+- Introduce RequestLogStore (ts_web_serviceworker/classes.requestlogstore.ts) to collect, persist in-memory, and compute stats for TypedRequest traffic (logs, counts, methods, averages).
+- Add service worker backend handlers to receive and broadcast TypedRequest logs and to expose endpoints: serviceworker_typedRequestLog, serviceworker_getTypedRequestLogs, serviceworker_getTypedRequestStats, serviceworker_clearTypedRequestLogs.
+- Expose HTTP routes and fallback behaviors in the server built-in controller to serve the SW dashboard (GET /sw-dash and /sw-dash/bundle.js) and to return sensible 503 placeholders when the SW is not active.
+- Extend the service worker CacheManager and DashboardGenerator to serve TypedRequest-related endpoints (/sw-dash/requests, /sw-dash/requests/stats, /sw-dash/requests/methods) and to integrate RequestLogStore data into the dashboard APIs.
+- Add a Lit-based dashboard component sw-dash-requests (ts_swdash/sw-dash-requests.ts) and integrate it into the main sw-dash-app UI to display live TypedRequest traffic with filtering, payload toggles, pagination and clear logs action.
+- Enable client-side traffic logging from the injected reload checker (ts_web_inject/index.ts) by setting global TypedRouter hooks that send log entries to the service worker, with safeguards to avoid logging the logging requests themselves.
+- Add action manager utilities (ts_web_serviceworker_client/classes.actionmanager.ts) to log TypedRequest entries to the SW, query logs and stats, clear logs, and subscribe to real-time TypedRequest broadcasts.
+- Refactor Dashboard HTML generation to use the shared SW_DASH_HTML constant so server and service worker serve the same UI shell.
+- Integrate broadcasting of TypedRequest log events from service worker backend to connected clients so the SW dashboard updates in real time.
+
+## 2025-12-04 - 7.7.1 - fix(web_serviceworker)
+Standardize DeesComms message format in service worker backend
+
+- Add createMessage helper to generate consistent TypedRequest-shaped messages (includes messageId and correlation.id/phase).
+- Replace inline postMessage payloads with createMessage(...) calls across ServiceworkerBackend (status updates, new-version broadcasts, alerts, event pushes, metrics updates, resource-cached notifications).
+- Improves message consistency and enables easier correlation/tracing of DeesComms messages; behavior should remain backward-compatible.
+
+## 2025-12-04 - 7.7.0 - feat(typedserver)
+Add SPA fallback support to TypedServer
+
+- Introduce new IServerOptions.spaFallback boolean to enable SPA routing fallback.
+- When enabled, GET requests for paths without a file extension will serve serveDir/index.html.
+- Preserves existing HTML injection behavior: injectReload still injects devtools script and typedserver metadata into <head> when enabled.
+- Responses from SPA fallback include Cache-Control: no-cache and appHash header for cache-busting; falls through to 404 on errors.
+- Non-file routes that contain a dot (.) are not considered for SPA fallback to avoid interfering with asset requests.
+
+## 2025-12-04 - 7.6.0 - feat(typedserver)
+Remove legacy Express-based servertools, drop express deps, and refactor TypedServer to SmartServe + typedrouter with CORS support
+
+- Remove legacy ts/servertools module and many Express-based helpers (classes.server, handler, handlerstatic, handlerproxy, compressor, sitemap, feed, tools.*). The servertools compatibility layer is no longer available.
+- Drop express-related dependencies from package.json (@types/express, express, body-parser, cors, express-force-ssl).
+- Refactor core API: ts/index.ts no longer exports servertools and ts/plugins.ts no longer re-exports Express middleware — consumers must migrate to SmartServe/typedrequest/typedsocket primitives.
+- TypedServer rewritten: integrates with @push.rocks/smartserve ControllerRegistry, adds custom route parsing, CORS header helper and OPTIONS preflight handling, improved static file handling with optional reload injection, file watching, typedrouter and typedsocket integration.
+- UtilityWebsiteServer now registers the serviceworker versionInfo handler on typedrouter instead of using the removed servertools.serviceworker helper.
+- This is a breaking change — public APIs and dependency surface changed; bump major version.
+
+## 2025-12-04 - 7.5.0 - feat(serviceworker)
+Add real-time service worker push updates and DeesComms integration (metrics, events, resource caching)
+
+- Integrate DeesComms push channel for real-time SW → client communication and export/consume deesComms in relevant plugin modules.
+- Add typed push message interfaces for events, metrics snapshots and resource-cached notifications in serviceworker interfaces.
+- Implement backend push methods: pushEvent, pushMetricsUpdate (with 500ms throttle) and pushResourceCached in ServiceworkerBackend.
+- Trigger push updates from MetricsCollector and PersistentStore so metrics and logged events are broadcast to connected clients.
+- Add client-side DeesComms handlers in sw-dash app: receive metrics, event logs and resource notifications; add heartbeat and initial HTTP seed to maintain SW health state.
+- Add event push listener and cleanup in sw-dash-events component to prepend incoming events and avoid leaks.
+- Expose getServiceWorkerBackend() from SW init for internal modules to call push methods.
+- Misc: implement request deduplication and various robustness improvements (throttling, heartbeat, safer polling, removed noisy debug logs).
+
+## 2025-12-04 - 7.4.1 - fix(web_serviceworker)
+Improve service worker persistence, metrics and caching robustness
+
+- Ensure persistent store is initialized before use in dashboard handlers and service worker activation/handlers (calls to persistentStore.init())
+- Make serveCumulativeMetrics async and align fetchEvent.respondWith usage (remove unnecessary Promise.resolve)
+- Change persistent WebStore database name to 'losslessServiceworkerPersistent' to separate durable store from runtime store
+- Make PersistentStore.init() more resilient: add detailed logging, avoid throwing on init failure, mark initialized to prevent retry loops, and start periodic save only after load
+- Ensure logEvent awaits initialization and adds defensive logging around reading/writing the event log
+- Add request deduplication logic and improved cache handling in CacheManager (fetchWithDeduplication usage and safer respondWith)
+
 ## 2025-12-04 - 7.4.0 - feat(serviceworker)
 Add persistent event store, cumulative metrics and dashboard events UI for service worker observability

--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@api.global/typedserver",
-  "version": "7.4.0",
+  "version": "7.8.3",
  "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
  "type": "module",
  "exports": {
@@ -32,7 +32,6 @@
    "HTTP server",
    "SSL",
    "cors",
-    "express middleware",
    "proxy",
    "sitemap",
    "feeds",
@@ -92,11 +91,6 @@
    "@push.rocks/webrequest": "^4.0.1",
    "@push.rocks/webstore": "^2.0.20",
    "@tsclass/tsclass": "^9.3.0",
-    "@types/express": "^5.0.6",
-    "body-parser": "^2.2.1",
-    "cors": "^2.8.5",
-    "express": "^5.2.1",
-    "express-force-ssl": "^0.3.2",
    "lit": "^3.3.1"
  },
  "devDependencies": {
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -107,21 +107,6 @@ importers:
      '@tsclass/tsclass':
        specifier: ^9.3.0
        version: 9.3.0
-      '@types/express':
-        specifier: ^5.0.6
-        version: 5.0.6
-      body-parser:
-        specifier: ^2.2.1
-        version: 2.2.1
-      cors:
-        specifier: ^2.8.5
-        version: 2.8.5
-      express:
-        specifier: ^5.2.1
-        version: 5.2.1
-      express-force-ssl:
-        specifier: ^0.3.2
-        version: 0.3.2
      lit:
        specifier: ^3.3.1
        version: 3.3.1
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: '@api.global/typedserver',
-  version: '7.4.0',
+  version: '7.8.0',
  description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }
--- a/ts/classes.typedserver.ts
+++ b/ts/classes.typedserver.ts
@@ -56,6 +56,12 @@ export interface IServerOptions {
  feedMetadata?: plugins.smartfeed.IFeedOptions;
  articleGetterFunction?: () => Promise<plugins.tsclass.content.IArticle[]>;
  blockWaybackMachine?: boolean;
+
+  /**
+   * SPA fallback - serve index.html for non-file routes (e.g., /login, /dashboard)
+   * Useful for single-page applications with client-side routing
+   */
+  spaFallback?: boolean;
 }

 export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'ALL';
@@ -381,6 +387,25 @@ export class TypedServer {
    };
  }

+  /**
+   * Add CORS headers to a response
+   */
+  private addCorsHeaders(response: Response): Response {
+    if (!this.options.cors) return response;
+
+    const headers = new Headers(response.headers);
+    headers.set('Access-Control-Allow-Origin', '*');
+    headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, PATCH');
+    headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With');
+    headers.set('Access-Control-Max-Age', '86400');
+
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+
  /**
   * Main request handler - routes to appropriate sub-handlers
   */
@@ -389,6 +414,25 @@ export class TypedServer {
    const path = url.pathname;
    const method = request.method.toUpperCase() as THttpMethod;

+    // Handle OPTIONS preflight for CORS
+    if (method === 'OPTIONS' && this.options.cors) {
+      return this.addCorsHeaders(new Response(null, { status: 204 }));
+    }
+
+    // Process the request and wrap response with CORS headers
+    const response = await this.handleRequestInternal(request, url, path, method);
+    return this.addCorsHeaders(response);
+  }
+
+  /**
+   * Internal request handler - routes to appropriate sub-handlers
+   */
+  private async handleRequestInternal(
+    request: Request,
+    url: URL,
+    path: string,
+    method: THttpMethod
+  ): Promise<Response> {
    // First, try to match via ControllerRegistry (decorated routes)
    const match = plugins.smartserve.ControllerRegistry.matchRoute(path, method);
    if (match) {
@@ -453,6 +497,41 @@ export class TypedServer {
      });
    }

+    // SPA fallback - serve index.html for non-file routes
+    if (this.options.spaFallback && this.options.serveDir && method === 'GET' && !path.includes('.')) {
+      try {
+        const indexPath = plugins.path.join(this.options.serveDir, 'index.html');
+        let html = await plugins.fsInstance.file(indexPath).encoding('utf8').read() as string;
+
+        // Inject reload script if enabled
+        if (this.options.injectReload && html.includes('<head>')) {
+          const injection = `<head>
+                <!-- injected by @apiglobal/typedserver start -->
+                <script async defer type="module" src="/typedserver/devtools"></script>
+                <script>
+                  globalThis.typedserver = {
+                    lastReload: ${this.lastReload},
+                    versionInfo: ${JSON.stringify({}, null, 2)},
+                  }
+                </script>
+                <!-- injected by @apiglobal/typedserver stop -->
+              `;
+          html = html.replace('<head>', injection);
+        }
+
+        return new Response(html, {
+          status: 200,
+          headers: {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Cache-Control': 'no-cache, no-store, must-revalidate',
+            appHash: this.serveHash,
+          },
+        });
+      } catch {
+        // Fall through to 404
+      }
+    }
+
    // Not found
    return new Response('Not Found', { status: 404 });
  }
--- a/ts/controllers/controller.builtin.ts
+++ b/ts/controllers/controller.builtin.ts
@@ -124,6 +124,65 @@ export class BuiltInRoutesController {
    });
  }

+  @plugins.smartserve.Get('/sw-dash')
+  async getSwDash(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    // Import shared HTML from interfaces
+    const { SW_DASH_HTML } = await import('../../dist_ts_interfaces/serviceworker.js');
+    return new Response(SW_DASH_HTML, {
+      status: 200,
+      headers: { 'Content-Type': 'text/html' },
+    });
+  }
+
+  // SW-dash data routes - return empty/unavailable when SW isn't active
+  @plugins.smartserve.Get('/sw-dash/metrics')
+  async getSwDashMetrics(): Promise<Response> {
+    return new Response(JSON.stringify({ error: 'Service worker not active', data: null }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sw-dash/resources')
+  async getSwDashResources(): Promise<Response> {
+    return new Response(JSON.stringify({ error: 'Service worker not active', resources: [], domains: [], contentTypes: [], resourceCount: 0 }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sw-dash/events')
+  async getSwDashEvents(): Promise<Response> {
+    return new Response(JSON.stringify({ error: 'Service worker not active', events: [], total: 0 }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sw-dash/events/count')
+  async getSwDashEventsCount(): Promise<Response> {
+    return new Response(JSON.stringify({ error: 'Service worker not active', count: 0 }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sw-dash/cumulative-metrics')
+  async getSwDashCumulativeMetrics(): Promise<Response> {
+    return new Response(JSON.stringify({ error: 'Service worker not active', data: null }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sw-dash/speedtest')
+  async getSwDashSpeedtest(): Promise<Response> {
+    return new Response(JSON.stringify({ error: 'Service worker not active - speedtest unavailable' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
  @plugins.smartserve.Get('/sw-dash/bundle.js')
  async getSwDashBundle(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
    try {
@@ -144,4 +203,25 @@ export class BuiltInRoutesController {
      return new Response('SW-Dash bundle not found', { status: 404 });
    }
  }
+
+  @plugins.smartserve.Get('/serviceworker.bundle.js')
+  async getServiceWorkerBundle(): Promise<Response> {
+    try {
+      const bundleContent = (await plugins.fsInstance
+        .file(paths.serviceworkerBundlePath)
+        .encoding('utf8')
+        .read()) as string;
+
+      return new Response(bundleContent, {
+        status: 200,
+        headers: {
+          'Content-Type': 'text/javascript',
+          'Cache-Control': 'no-cache',
+        },
+      });
+    } catch (error) {
+      console.error('Failed to serve serviceworker bundle:', error);
+      return new Response('ServiceWorker bundle not found', { status: 404 });
+    }
+  }
 }
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -1,15 +1,7 @@
 import * as plugins from './plugins.js';

-import * as servertools from './servertools/index.js';
-
-export { servertools };
-
 export * from './classes.typedserver.js';

-// Type helpers - using native Web API Request/Response types
-// Native Request and Response are available in Node.js 18+ and all modern browsers
-// Legacy Express types are available via servertools for backward compatibility
-
 // lets export utilityservers
 import * as utilityservers from './utilityservers/index.js';
 export { utilityservers };
--- a/ts/paths.ts
+++ b/ts/paths.ts
@@ -9,6 +9,7 @@ export const injectBundleDir = plugins.path.join(packageDir, './dist_ts_web_inje
 export const injectBundlePath = plugins.path.join(injectBundleDir, './bundle.js');

 export const serviceworkerBundleDir = plugins.path.join(packageDir, './dist_ts_web_serviceworker');
+export const serviceworkerBundlePath = plugins.path.join(serviceworkerBundleDir, './serviceworker.bundle.js');

 export const swdashBundleDir = plugins.path.join(packageDir, './dist_ts_swdash');
 export const swdashBundlePath = plugins.path.join(swdashBundleDir, './bundle.js');
--- a/ts/plugins.ts
+++ b/ts/plugins.ts
@@ -65,12 +65,3 @@ export const fsInstance = new smartfs.SmartFs(new smartfs.SmartFsProviderNode())
 import * as smartserve from '@push.rocks/smartserve';

 export { smartserve };
-
-// Legacy Express dependencies - kept for backward compatibility with deprecated servertools
-// These will be removed in the next major version
-import express from 'express';
-import bodyParser from 'body-parser';
-import cors from 'cors';
-import expressForceSsl from 'express-force-ssl';
-
-export { express, bodyParser, cors, expressForceSsl };
--- a/ts/servertools/classes.compressor.ts
+++ b/ts/servertools/classes.compressor.ts
@@ -1,131 +0,0 @@
-import * as plugins from '../plugins.js';
-
-export type TCompressionMethod = 'gzip' | 'deflate' | 'br' | 'none';
-export interface ICompressionResult {
-  result: Buffer;
-  compressionMethod: TCompressionMethod;
-}
-
-export class Compressor {
-  private _cache: Map<string, Buffer>;
-  private MAX_CACHE_SIZE: number = 100 * 1024 * 1024; // 100 MB
-
-  constructor() {
-    this._cache = new Map<string, Buffer>();
-  }
-
-  private _addToCache(key: string, value: Buffer) {
-    this._cache.set(key, value);
-    this._manageCacheSize();
-  }
-
-  private _manageCacheSize() {
-    let currentSize = Array.from(this._cache.values()).reduce((acc, buffer) => acc + buffer.length, 0);
-
-    while (currentSize > this.MAX_CACHE_SIZE) {
-      const firstKey = this._cache.keys().next().value;
-      const firstValue = this._cache.get(firstKey)!;
-      currentSize -= firstValue.length;
-      this._cache.delete(firstKey);
-    }
-  }
-
-  public async compressContent(
-    content: Buffer,
-    method: 'gzip' | 'deflate' | 'br' | 'none'
-  ): Promise<Buffer> {
-    const cacheKey = content.toString('base64') + method;
-    const cachedResult = this._cache.get(cacheKey);
-
-    if (cachedResult) {
-      return cachedResult;
-    }
-
-    return new Promise((resolve, reject) => {
-      const callback = (err: Error | null, result: Buffer) => {
-        if (err) reject(err);
-        else {
-          this._addToCache(cacheKey, result);
-          resolve(result);
-        }
-      };
-
-      switch (method) {
-        case 'gzip':
-          plugins.zlib.gzip(content, {
-            level: 1,
-          },callback,);
-          break;
-        case 'br':
-          plugins.zlib.brotliCompress(content, {}, callback);
-          break;
-        case 'deflate':
-          plugins.zlib.deflate(content, callback);
-          break;
-        default:
-          this._addToCache(cacheKey, content);
-          resolve(content);
-      }
-    });
-  }
-
-  public determineCompression(acceptEncoding: string | string[], preferredCompressionMethodsArg: TCompressionMethod[] = []) {
-    // Ensure acceptEncoding is a single string
-    const encodingString = Array.isArray(acceptEncoding)
-      ? acceptEncoding.join(', ')
-      : acceptEncoding;
-
-    let compressionMethod: TCompressionMethod = 'none';
-
-    // Prioritize preferred compression methods if provided
-    for (const preferredMethod of preferredCompressionMethodsArg) {
-      if (new RegExp(`\\b${preferredMethod}\\b`).test(encodingString)) {
-        return preferredMethod;
-      }
-    }
-
-    // Fallback to default prioritization if no preferred method matches
-    if (/\bbr\b/.test(encodingString)) {
-      compressionMethod = 'br';
-    } else if (/\bgzip\b/.test(encodingString)) {
-      compressionMethod = 'gzip';
-    } else if (/\bdeflate\b/.test(encodingString)) {
-      compressionMethod = 'deflate';
-    }
-
-    return compressionMethod;
-  }
-
-  public async maybeCompress(requestHeaders: plugins.http.IncomingHttpHeaders, content: Buffer, preferredCompressionMethodsArg?: TCompressionMethod[]): Promise<ICompressionResult> {
-    const acceptEncoding = requestHeaders['accept-encoding'];
-    const compressionMethod = this.determineCompression(acceptEncoding, preferredCompressionMethodsArg);
-    const result = await this.compressContent(content, compressionMethod);
-    return {
-      result,
-      compressionMethod,
-    };
-  }
-
-  public createCompressionStream(method: 'gzip' | 'deflate' | 'br' | 'none') {
-    let compressionStream: any;
-    switch (method) {
-      case 'gzip':
-        compressionStream = plugins.zlib.createGzip();
-        return compressionStream;
-      case 'br':
-        compressionStream = plugins.zlib.createBrotliCompress({
-          chunkSize: 16 * 1024,
-          params: {
-            
-          },
-        });
-        return compressionStream;
-      case 'deflate':
-        compressionStream = plugins.zlib.createDeflate();
-        return compressionStream;
-      default:
-        compressionStream = plugins.smartstream.createPassThrough();
-        return compressionStream;
-    }
-  }
-}
--- a/ts/servertools/classes.feed.ts
+++ b/ts/servertools/classes.feed.ts
@@ -1,35 +0,0 @@
-import { Handler } from './classes.handler.js';
-import { Server } from './classes.server.js';
-import * as plugins from '../plugins.js';
-
-export class Feed {
-  public smartexpressRef: Server;
-  public smartfeedInstance = new plugins.smartfeed.Smartfeed();
-
-  public feedHandler = new Handler('GET', async (req, res) => {
-    if (!this.smartexpressRef.options.feedMetadata) {
-      res.status(500);
-      res.write('feed metadata is missing');
-      res.end();
-      return;
-    }
-    if (!this.smartexpressRef.options.articleGetterFunction) {
-      res.status(500);
-      res.write('no article getter function defined.');
-      res.end();
-      return;
-    }
-    const xmlString = await this.smartfeedInstance.createFeedFromArticleArray(
-      this.smartexpressRef.options.feedMetadata,
-      await this.smartexpressRef.options.articleGetterFunction()
-    );
-    res.type('.xml');
-    res.write(xmlString);
-    res.end();
-  });
-
-  constructor(smartexpressRefArg: Server) {
-    this.smartexpressRef = smartexpressRefArg;
-    this.smartexpressRef.addRouteBefore('/feed', this.feedHandler);
-  }
-}
--- a/ts/servertools/classes.handler.ts
+++ b/ts/servertools/classes.handler.ts
@@ -1,17 +0,0 @@
-import * as plugins from '../plugins.js';
-import { type Request, type Response } from 'express';
-
-export interface IHandlerFunction {
-  (requestArg: Request, responseArg: Response): void;
-}
-
-export type THttpMethods = 'ALL' | 'GET' | 'POST' | 'PUT' | 'DELETE';
-
-export class Handler {
-  httpMethod: THttpMethods;
-  handlerFunction: IHandlerFunction;
-  constructor(httpMethodArg: THttpMethods, handlerArg: IHandlerFunction) {
-    this.httpMethod = httpMethodArg;
-    this.handlerFunction = handlerArg;
-  }
-}
--- a/ts/servertools/classes.handlerproxy.ts
+++ b/ts/servertools/classes.handlerproxy.ts
@@ -1,132 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Handler } from './classes.handler.js';
-
-import * as interfaces from '../../dist_ts_interfaces/index.js';
-
-export class HandlerProxy extends Handler {
-  /**
-   * The constuctor of HandlerProxy
-   * @param remoteMountPointArg
-   */
-  constructor(
-    remoteMountPointArg: string,
-    optionsArg?: {
-      responseModifier?: interfaces.TResponseModifier;
-      headers?: { [key: string]: string };
-    }
-  ) {
-    super('ALL', async (req, res) => {
-      // 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.ICoreResponse;
-      try {
-        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;
-      }
-      const headers = proxiedResponse.headers;
-      for (const header of Object.keys(headers)) {
-        res.set(header, headers[header] as string);
-      }
-
-      // set additional headers
-      if (optionsArg && optionsArg.headers) {
-        for (const key of Object.keys(optionsArg.headers)) {
-          res.set(key, optionsArg.headers[key]);
-        }
-      }
-
-      // 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) {
-        const modifiedResponse = await optionsArg.responseModifier({
-          headers: res.getHeaders(),
-          path: req.path,
-          responseContent: responseToSend,
-        });
-
-        // headers
-        for (const key of Object.keys(res.getHeaders())) {
-          if (!modifiedResponse.headers[key]) {
-            res.removeHeader(key);
-          }
-        }
-
-        for (const key of Object.keys(modifiedResponse.headers)) {
-          res.setHeader(key, modifiedResponse.headers[key]);
-        }
-
-        // responseContent
-        responseToSend = modifiedResponse.responseContent;
-      }
-
-      res.status(200);
-      res.write(responseToSend);
-      res.end();
-    });
-  }
-}
--- a/ts/servertools/classes.handlerstatic.ts
+++ b/ts/servertools/classes.handlerstatic.ts
@@ -1,168 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as interfaces from '../../dist_ts_interfaces/index.js';
-
-import { Handler } from './classes.handler.js';
-import { Compressor, type TCompressionMethod, type ICompressionResult } from './classes.compressor.js';
-
-export class HandlerStatic extends Handler {
-  public compressor = new Compressor();
-  constructor(
-    pathArg: string,
-    optionsArg?: {
-      requestModifier?: interfaces.TRequestModifier;
-      responseModifier?: interfaces.TResponseModifier;
-      headers?: { [key: string]: string };
-      serveIndexHtmlDefault?: boolean;
-      enableCompression?: boolean;
-      preferredCompressionMethod?: TCompressionMethod;
-    }
-  ) {
-    super('GET', async (req, res) => {
-      let requestPath = req.path;
-      let requestHeaders = req.headers;
-      let requestBody = req.body;
-      let travelData: unknown;
-      if (optionsArg && optionsArg.requestModifier) {
-        const modifiedRequest = await optionsArg.requestModifier({
-          headers: requestHeaders,
-          path: requestPath,
-          body: requestBody,
-        });
-
-        requestHeaders = modifiedRequest.headers;
-        requestPath = modifiedRequest.path;
-        requestBody = modifiedRequest.body;
-        travelData = modifiedRequest.travelData;
-      }
-
-      // lets compute some paths
-      // 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';
-      }
-      console.log(filePath);
-      const joinedPath = plugins.path.join(pathArg, filePath);
-      const defaultPath = plugins.path.join(pathArg, 'index.html');
-      let parsedPath = plugins.path.parse(joinedPath);
-      let usedPath: string;
-
-      // important security checks
-      if (
-        requestPath.includes('..') || // don't allow going up the filePath
-        requestPath.includes('~') || // don't allow referencing of home directory
-        !joinedPath.startsWith(pathArg) // make sure the joined path is within the directory
-      ) {
-        res.writeHead(500);
-        res.end();
-        return;
-      }
-
-      // set additional headers
-      if (optionsArg && optionsArg.headers) {
-        for (const key of Object.keys(optionsArg.headers)) {
-          res.set(key, optionsArg.headers[key]);
-        }
-      }
-
-      // lets actually care about serving, if security checks pass
-      let fileBuffer: Buffer;
-      try {
-        fileBuffer = await plugins.fsInstance.file(joinedPath).read() as Buffer;
-        usedPath = joinedPath;
-      } catch (err) {
-        // try serving index.html instead
-        console.log(`could not resolve ${joinedPath}`);
-        if (optionsArg && optionsArg.serveIndexHtmlDefault) {
-          console.log(`serving default path ${defaultPath} instead of ${joinedPath}`);
-          try {
-            parsedPath = plugins.path.parse(defaultPath);
-            fileBuffer = await plugins.fsInstance.file(defaultPath).read() as Buffer;
-            usedPath = defaultPath;
-          } catch (err) {
-            res.writeHead(500);
-            res.end('File not found!');
-            return;
-          }
-        } else {
-          res.writeHead(500);
-          res.end('File not found!');
-          return;
-        }
-      }
-
-      res.type(parsedPath.ext);
-
-      const headers = res.getHeaders();
-
-      // lets modify the response at last
-      if (optionsArg && optionsArg.responseModifier) {
-        const modifiedResponse = await optionsArg.responseModifier({
-          headers: res.getHeaders(),
-          path: usedPath,
-          responseContent: fileBuffer,
-          travelData,
-        });
-
-        // headers
-        for (const key of Object.keys(res.getHeaders())) {
-          if (!modifiedResponse.headers[key]) {
-            res.removeHeader(key);
-          }
-        }
-
-        for (const key of Object.keys(modifiedResponse.headers)) {
-          res.setHeader(key, modifiedResponse.headers[key]);
-        }
-
-        // responseContent
-        fileBuffer = modifiedResponse.responseContent;
-      }
-
-      // lets finally deal with compression
-      let compressionResult: ICompressionResult;
-
-      if (optionsArg && optionsArg.enableCompression) {
-        compressionResult = await this.compressor.maybeCompress(requestHeaders, fileBuffer, [optionsArg.preferredCompressionMethod]);
-      } else {
-        compressionResult = {
-          compressionMethod: 'none',
-          result: fileBuffer,
-        };
-      }
-
-      res.status(200);
-      if (compressionResult?.compressionMethod) {
-        res.header('Content-Encoding', compressionResult.compressionMethod);
-        res.write(compressionResult.result);
-      } else {
-        res.write(fileBuffer);
-      }
-      res.end();
-    });
-  }
-}
--- a/ts/servertools/classes.handlertypedrouter.ts
+++ b/ts/servertools/classes.handlertypedrouter.ts
@@ -1,19 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Handler } from './classes.handler.js';
-
-import * as interfaces from '../../dist_ts_interfaces/index.js';
-
-export class HandlerTypedRouter extends Handler {
-  /**
-   * The constuctor of HandlerProxy
-   * @param remoteMountPointArg
-   */
-  constructor(typedrouter: plugins.typedrequest.TypedRouter) {
-    super('POST', async (req, res) => {
-      const response = await typedrouter.routeAndAddResponse(req.body);
-      res.type('json');
-      res.write(plugins.smartjson.stringify(response));
-      res.end();
-    });
-  }
-}
--- a/ts/servertools/classes.route.ts
+++ b/ts/servertools/classes.route.ts
@@ -1,37 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Handler } from './classes.handler.js';
-import { Server } from './classes.server.js';
-
-import { type IRoute as IExpressRoute } from 'express';
-
-export class Route {
-  public routeString: string;
-
-  /**
-   * an object map of handlers
-   * Why multiple? Because GET, POST, PUT, DELETE, etc. can all have different handlers
-   */
-  public handlerObjectMap = new plugins.lik.ObjectMap<Handler>();
-  
-  public expressMiddlewareObjectMap = new plugins.lik.ObjectMap<any>();
-  public expressRoute: IExpressRoute; // will be set to server route on server start
-  constructor(ServerArg: Server, routeStringArg: string) {
-    this.routeString = routeStringArg;
-  }
-
-  /**
-   * add a handler to do something with requests
-   * @param handlerArg
-   */
-  public addHandler(handlerArg: Handler) {
-    this.handlerObjectMap.add(handlerArg);
-  }
-
-  /**
-   * add a express middleware
-   * @param middlewareArg
-   */
-  public addExpressMiddleWare(middlewareArg: plugins.express.Application) {
-    this.expressMiddlewareObjectMap.add(middlewareArg);
-  }
-}
--- a/ts/servertools/classes.server.ts
+++ b/ts/servertools/classes.server.ts
@@ -1,345 +0,0 @@
-import * as plugins from '../plugins.js';
-
-import { Route } from './classes.route.js';
-import { Handler } from './classes.handler.js';
-import { HandlerTypedRouter } from './classes.handlertypedrouter.js';
-
-// export types
-import { setupRobots } from './tools.robots.js';
-import { setupManifest } from './tools.manifest.js';
-import { Sitemap } from './classes.sitemap.js';
-import { Feed } from './classes.feed.js';
-import { type IServerOptions } from '../classes.typedserver.js';
-export type TServerStatus = 'initiated' | 'running' | 'stopped';
-
-/**
- * can be used to spawn a server to answer http/https calls
- * for constructor options see [[IServerOptions]]
- */
-export class Server {
-  public httpServer: plugins.http.Server | plugins.https.Server;
-  public expressAppInstance: plugins.express.Application;
-  public routeObjectMap = new Array<Route>();
-  public options: IServerOptions;
-  public serverStatus: TServerStatus = 'initiated';
-
-  public feed: Feed;
-  public sitemap: Sitemap;
-
-  public executeAfterStartFunctions: (() => Promise<void>)[] = [];
-
-  // do stuff when server is ready
-  private startedDeferred = plugins.smartpromise.defer();
-  // tslint:disable-next-line:member-ordering
-  public startedPromise = this.startedDeferred.promise;
-
-  private socketMap = new plugins.lik.ObjectMap<plugins.net.Socket>();
-
-  constructor(optionsArg: IServerOptions) {
-    this.options = {
-      ...optionsArg,
-    };
-  }
-
-  /**
-   * allows updating of server options
-   * @param optionsArg
-   */
-  public updateServerOptions(optionsArg: IServerOptions) {
-    Object.assign(this.options, optionsArg);
-  }
-
-  public addTypedRequest(typedrouter: plugins.typedrequest.TypedRouter) {
-    this.addRoute('/typedrequest', new HandlerTypedRouter(typedrouter));
-  }
-
-  /**
-   * @deprecated This method is deprecated. Use TypedServer with SmartServe integration instead.
-   * TypedSocket v4 no longer supports attaching to an existing Express server.
-   */
-  public addTypedSocket(typedrouter: plugins.typedrequest.TypedRouter): void {
-    console.warn(
-      '[DEPRECATED] servertools.Server.addTypedSocket() is deprecated and has no effect. ' +
-      'Use TypedServer with SmartServe integration for WebSocket support.'
-    );
-    // TypedSocket v4 creates its own server, which would conflict with Express.
-    // This method is now a no-op for backward compatibility.
-  }
-
-  public addRoute(routeStringArg: string, handlerArg?: Handler) {
-    const route = new Route(this, routeStringArg);
-    if (handlerArg) {
-      route.addHandler(handlerArg);
-    }
-    this.routeObjectMap.push(route);
-    return route;
-  }
-
-  public addRouteBefore(routeStringArg: string, handlerArg?: Handler) {
-    const route = new Route(this, routeStringArg);
-    if (handlerArg) {
-      route.addHandler(handlerArg);
-    }
-    this.routeObjectMap.unshift(route);
-    return route;
-  }
-
-  /**
-   * starts the server and sets up the routes
-   * @param portArg
-   * @param doListen
-   */
-  public async start(portArg: number | string = this.options.port, doListen = true) {
-    const done = plugins.smartpromise.defer();
-
-    if (typeof portArg === 'string') {
-      portArg = parseInt(portArg);
-    }
-
-    this.expressAppInstance = plugins.express();
-    if (!this.httpServer && (!this.options.privateKey || !this.options.publicKey)) {
-      console.log('Got no SSL certificates. Please ensure encryption using e.g. a reverse proxy');
-      this.httpServer = plugins.http.createServer(this.expressAppInstance);
-    } else if (!this.httpServer) {
-      console.log('Got SSL certificate. Using it for the http server');
-      this.httpServer = plugins.https.createServer(
-        {
-          key: this.options.privateKey,
-          cert: this.options.publicKey,
-        },
-        this.expressAppInstance
-      );
-    } else {
-      console.log('Using externally supplied http server');
-    }
-    this.httpServer.keepAliveTimeout = 600 * 1000;
-    this.httpServer.headersTimeout = 20 * 1000;
-
-    // general request handlling
-    this.expressAppInstance.use((req, res, next) => {
-      next();
-    });
-
-    // forceSsl
-    if (this.options.forceSsl) {
-      this.expressAppInstance.set('forceSSLOptions', {
-        enable301Redirects: true,
-        trustXFPHeader: true,
-        sslRequiredMessage: 'SSL Required.',
-      });
-      this.expressAppInstance.use(plugins.expressForceSsl);
-    }
-
-    // cors
-    if (this.options.cors) {
-      const cors = plugins.cors({
-        allowedHeaders: '*',
-        methods: '*',
-        origin: '*',
-      });
-
-      this.expressAppInstance.use(cors);
-      this.expressAppInstance.options('/{*splat}', cors);
-    }
-
-    this.expressAppInstance.use((req, res, next) => {
-      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
-      res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
-      res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
-      res.setHeader('Access-Control-Allow-Origin', '*');
-      res.setHeader('SERVEZONE_ROUTE', 'LOSSLESS_ORIGIN_CONTAINER');
-      res.setHeader('Cache-Control', 'no-cache');
-      res.setHeader('Expires', new Date(Date.now()).toUTCString());
-      next();
-    });
-
-    // body parsing
-    this.expressAppInstance.use(async (req, res, next) => {
-      if (req.headers['content-type'] === 'application/json') {
-        let data = '';
-        req.on('data', chunk => {
-          data += chunk;
-        });
-        req.on('end', () => {
-          try {
-            req.body = plugins.smartjson.parse(data);
-            next();
-          } catch (error) {
-            res.status(400).send('Invalid JSON');
-          }
-        });
-      } else {
-        next();
-      }
-    });
-    this.expressAppInstance.use(plugins.bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded
-
-    // robots
-    if (this.options.robots && this.options.domain) {
-      await setupRobots(this, this.options.domain);
-    }
-
-    // manifest.json
-    if (this.options.manifest) {
-      await setupManifest(this.expressAppInstance, this.options.manifest);
-    }
-
-    // sitemaps
-    if (this.options.sitemap) {
-      this.sitemap = new Sitemap(this);
-    }
-
-    if (this.options.feed) {
-      // feed
-      this.feed = new Feed(this);
-    }
-
-    // appVersion
-    if (this.options.appVersion) {
-      this.expressAppInstance.use((req, res, next) => {
-        res.set('appversion', this.options.appVersion);
-        next();
-      });
-      this.addRoute(
-        '/appversion',
-        new Handler('GET', async (req, res) => {
-          res.write(this.options.appVersion);
-          res.end();
-        })
-      );
-    }
-
-    // set up routes in for express
-    await this.routeObjectMap.forEach(async (routeArg) => {
-      console.log(
-        `"${routeArg.routeString}" maps to ${routeArg.handlerObjectMap.getArray().length} handlers`
-      );
-      const expressRoute = this.expressAppInstance.route(routeArg.routeString);
-      routeArg.handlerObjectMap.forEach(async (handler) => {
-        console.log(` -> ${handler.httpMethod}`);
-        switch (handler.httpMethod) {
-          case 'GET':
-            expressRoute.get(handler.handlerFunction);
-            return;
-          case 'POST':
-            expressRoute.post(handler.handlerFunction);
-            return;
-          case 'PUT':
-            expressRoute.put(handler.handlerFunction);
-            return;
-          case 'ALL':
-            expressRoute.all(handler.handlerFunction);
-            return;
-          case 'DELETE':
-            expressRoute.delete(handler.handlerFunction);
-            return;
-          default:
-            return;
-        }
-      });
-    });
-
-    if (this.options.defaultAnswer) {
-      this.expressAppInstance.get('/', async (request, response) => {
-        response.send(await this.options.defaultAnswer());
-      });
-    }
-
-    this.httpServer.on('connection', (connection: plugins.net.Socket) => {
-      this.socketMap.add(connection);
-      console.log(`added connection. now ${this.socketMap.getArray().length} sockets connected.`);
-      
-      const closeListener = () => {
-        console.log('connection closed');
-        cleanupConnection();
-      };
-      
-      const errorListener = () => {
-        console.log('connection errored');
-        cleanupConnection();
-      };
-      
-      const endListener = () => {
-        console.log('connection ended');
-        cleanupConnection();
-      };
-      
-      const timeoutListener = () => {
-        console.log('connection timed out');
-        cleanupConnection();
-      };
-      
-      connection.addListener('close', closeListener);
-      connection.addListener('error', errorListener);
-      connection.addListener('end', endListener);
-      connection.addListener('timeout', timeoutListener);
-      
-      const cleanupConnection = async () => {
-        connection.removeListener('close', closeListener);
-        connection.removeListener('error', errorListener);
-        connection.removeListener('end', endListener);
-        connection.removeListener('timeout', timeoutListener);
-        
-        if (this.socketMap.checkForObject(connection)) {
-          this.socketMap.remove(connection);
-          console.log(`removed connection. ${this.socketMap.getArray().length} sockets remaining.`);
-          await plugins.smartdelay.delayFor(0);
-          if (connection.destroyed === false) {
-            connection.destroy();
-          }
-        }
-      };
-    });
-
-    // finally listen on a port
-    if (doListen) {
-      this.httpServer.listen(portArg, '0.0.0.0', () => {
-        console.log(`now listening on ${portArg}!`);
-        this.startedDeferred.resolve();
-        this.serverStatus = 'running';
-        done.resolve();
-      });
-    } else {
-      console.log(
-        'The server does not listen on a network stack and instead expects to get handed requests by other mechanics'
-      );
-    }
-    await done.promise;
-    for (const executeAfterStartFunction of this.executeAfterStartFunctions) {
-      await executeAfterStartFunction();
-    }
-  }
-
-  public getHttpServer() {
-    return this.httpServer;
-  }
-
-  public getExpressAppInstance() {
-    return this.expressAppInstance;
-  }
-
-  public async stop() {
-    const done = plugins.smartpromise.defer();
-    if (this.httpServer) {
-      this.httpServer.close(async () => {
-        this.serverStatus = 'stopped';
-        done.resolve();
-      });
-      await this.socketMap.forEach(async (socket) => {
-        socket.destroy();
-      });
-    } else {
-      throw new Error('There is no Server to be stopped. Have you started it?');
-    }
-    return await done.promise;
-  }
-
-  /**
-   * allows handling requests and responses that come from other
-   * @param req
-   * @param res
-   */
-  public async handleReqRes(req: plugins.express.Request, res: plugins.express.Response) {
-    this.expressAppInstance(req, res);
-  }
-}
--- a/ts/servertools/classes.sitemap.ts
+++ b/ts/servertools/classes.sitemap.ts
@@ -1,68 +0,0 @@
-import { Server } from './classes.server.js';
-import { Handler } from './classes.handler.js';
-import * as plugins from '../plugins.js';
-import { type IUrlInfo } from '@push.rocks/smartsitemap';
-
-export class Sitemap {
-  public smartexpressRef: Server;
-  public smartSitemap = new plugins.smartsitemap.SmartSitemap();
-  public urls: plugins.smartsitemap.IUrlInfo[] = [];
-
-  /**
-   * handles the normal sitemap request
-   */
-  public sitemapHandler = new Handler('GET', async (req, res) => {
-    const sitemapXmlString = await this.smartSitemap.createSitemapFromUrlInfoArray(this.urls);
-    res.type('.xml');
-    res.write(sitemapXmlString);
-    res.end();
-  });
-
-  /**
-   * handles the sitemap-news request
-   */
-  public sitemapNewsHandler = new Handler('GET', async (req, res) => {
-    if (!this.smartexpressRef.options.articleGetterFunction) {
-      res.status(500);
-      res.write('no article getter function defined.');
-      res.end();
-      return;
-    }
-    const sitemapNewsXml = await this.smartSitemap.createSitemapNewsFromArticleArray(
-      await this.smartexpressRef.options.articleGetterFunction()
-    );
-    res.type('.xml');
-    res.write(sitemapNewsXml);
-    res.end();
-  });
-
-  constructor(smartexpressRefArg: Server) {
-    this.smartexpressRef = smartexpressRefArg;
-    this.smartexpressRef.addRouteBefore('/sitemap', this.sitemapHandler);
-    this.smartexpressRef.addRouteBefore('/sitemap-news', this.sitemapNewsHandler);
-
-    // lets set the default url
-    if (this.smartexpressRef.options.domain) {
-      this.urls.push({
-        url: `https://${this.smartexpressRef.options.domain}/`,
-        timestamp: Date.now(),
-        frequency: 'daily',
-      });
-    }
-  }
-
-  /**
-   * replaces the current urlsArray
-   * @param urlsArg
-   */
-  public replaceUrls(urlsArg: IUrlInfo[]) {
-    this.urls = urlsArg;
-  }
-
-  /**
-   * adds urls to the current set of urls
-   */
-  public addUrls(urlsArg: IUrlInfo[]) {
-    this.urls = this.urls.concat(urlsArg);
-  }
-}
--- a/ts/servertools/index.ts
+++ b/ts/servertools/index.ts
@@ -1,22 +0,0 @@
-// Core utilities that don't depend on Express
-export * from './classes.compressor.js';
-
-// Legacy Express-based classes - deprecated, will be removed in next major version
-// These are kept for backward compatibility but should not be used for new code
-// Use SmartServe decorator-based controllers instead
-/** @deprecated Use SmartServe directly */
-export * from './classes.server.js';
-/** @deprecated Use SmartServe @Route decorator */
-export * from './classes.route.js';
-/** @deprecated Use SmartServe @Get/@Post decorators */
-export * from './classes.handler.js';
-/** @deprecated Use SmartServe static file serving */
-export * from './classes.handlerstatic.js';
-/** @deprecated Use SmartServe custom handler */
-export * from './classes.handlerproxy.js';
-/** @deprecated Use SmartServe TypedRouter integration */
-export * from './classes.handlertypedrouter.js';
-
-// Service worker utilities - uses legacy patterns, will be migrated
-import * as serviceworker from './tools.serviceworker.js';
-export { serviceworker };
--- a/ts/servertools/tools.manifest.ts
+++ b/ts/servertools/tools.manifest.ts
@@ -1,14 +0,0 @@
-import * as plugins from '../plugins.js';
-
-export const setupManifest = async (
-  expressInstanceArg: plugins.express.Application,
-  manifestArg: plugins.smartmanifest.ISmartManifestConstructorOptions
-) => {
-  const smartmanifestInstance = new plugins.smartmanifest.SmartManifest(manifestArg);
-  expressInstanceArg.get('/manifest.json', async (req, res) => {
-    res.status(200);
-    res.type('json');
-    res.write(smartmanifestInstance.jsonString());
-    res.end();
-  });
-};
--- a/ts/servertools/tools.robots.ts
+++ b/ts/servertools/tools.robots.ts
@@ -1,33 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Server } from './classes.server.js';
-import { Handler } from './classes.handler.js';
-
-export const setupRobots = async (smartexpressRefArg: Server, domainArg: string) => {
-  smartexpressRefArg.addRouteBefore(
-    '/robots.txt',
-    new Handler('GET', async (req, res) => {
-      res.type('text/plain');
-      res.send(`
-User-agent: Googlebot-News
-Disallow: /account
-Disallow: /login
-
-User-agent: *
-Disallow: /account
-Disallow: /login
-
-${
-  smartexpressRefArg.options.blockWaybackMachine
-    ? `
-User-Agent: ia_archiver
-Disallow: /
-`
-    : ``
-}
-
-Sitemap: https://${domainArg}/sitemap
-Sitemap: https://${domainArg}/sitemap-news
-`);
-    })
-  );
-};
--- a/ts/servertools/tools.serviceworker.ts
+++ b/ts/servertools/tools.serviceworker.ts
@@ -1,134 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as paths from '../paths.js';
-
-import * as interfaces from '../../dist_ts_interfaces/index.js';
-import type { TypedServer } from '../classes.typedserver.js';
-
-// Lazy-loaded service worker bundle content
-let swBundleJs: string | null = null;
-let swBundleJsMap: string | null = null;
-
-const loadServiceWorkerBundle = async (): Promise<void> => {
-  if (swBundleJs === null) {
-    swBundleJs = (await plugins.fsInstance
-      .file(plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js'))
-      .encoding('utf8')
-      .read()) as string;
-  }
-  if (swBundleJsMap === null) {
-    swBundleJsMap = (await plugins.fsInstance
-      .file(plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js.map'))
-      .encoding('utf8')
-      .read()) as string;
-  }
-};
-
-let swVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
-  null;
-
-export const addServiceWorkerRoute = (
-  typedserverInstance: TypedServer,
-  swDataFunc: () => interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response']
-) => {
-  // Set the version info
-  swVersionInfo = swDataFunc();
-
-  // Handler function for serviceworker bundle requests
-  const handleServiceWorkerRequest = async (request: Request): Promise<Response> => {
-    await loadServiceWorkerBundle();
-    const url = new URL(request.url);
-    const path = url.pathname;
-
-    if (path === '/serviceworker/serviceworker.bundle.js' || path === '/serviceworker.bundle.js') {
-      return new Response(
-        swBundleJs + '\n' + `/** appSemVer: ${swVersionInfo?.appSemVer || 'not set'} */`,
-        {
-          status: 200,
-          headers: { 'Content-Type': 'text/javascript' },
-        }
-      );
-    } else if (
-      path === '/serviceworker/serviceworker.bundle.js.map' ||
-      path === '/serviceworker.bundle.js.map'
-    ) {
-      return new Response(swBundleJsMap, {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-
-    return null;
-  };
-
-  // Service worker bundle handler - nested path
-  typedserverInstance.addRoute('/serviceworker/*splat', 'GET', handleServiceWorkerRequest);
-
-  // Service worker bundle handler - root level (for /serviceworker.bundle.js)
-  typedserverInstance.addRoute('/serviceworker.bundle.js', 'GET', handleServiceWorkerRequest);
-  typedserverInstance.addRoute('/serviceworker.bundle.js.map', 'GET', handleServiceWorkerRequest);
-
-  // Typed request handler for service worker
-  typedserverInstance.addRoute('/sw-typedrequest', 'POST', async (request: Request) => {
-    try {
-      const body = await request.json();
-
-      // Create a local typed router for service worker requests
-      const typedrouter = new plugins.typedrequest.TypedRouter();
-
-      typedrouter.addTypedHandler(
-        new plugins.typedrequest.TypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>(
-          'serviceworker_versionInfo',
-          async () => {
-            return swDataFunc();
-          }
-        )
-      );
-
-      // Speedtest handler for measuring connection speed (time-based chunked approach)
-      typedrouter.addTypedHandler(
-        new plugins.typedrequest.TypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Speedtest>(
-          'serviceworker_speedtest',
-          async (reqArg) => {
-            const chunkSizeKB = reqArg.chunkSizeKB || 64;
-            const sizeBytes = chunkSizeKB * 1024;
-            let payload: string | undefined;
-            let bytesTransferred = 0;
-
-            switch (reqArg.type) {
-              case 'download_chunk':
-                // Generate chunk payload for download test
-                payload = 'x'.repeat(sizeBytes);
-                bytesTransferred = sizeBytes;
-                break;
-              case 'upload_chunk':
-                // For upload, measure bytes received from client
-                bytesTransferred = reqArg.payload?.length || 0;
-                break;
-              case 'latency':
-                // Simple ping - no payload needed
-                bytesTransferred = 0;
-                break;
-            }
-
-            return {
-              bytesTransferred,
-              timestamp: Date.now(),
-              payload, // Only for download_chunk tests
-            };
-          }
-        )
-      );
-
-      const response = await typedrouter.routeAndAddResponse(body);
-      return new Response(plugins.smartjson.stringify(response), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      return new Response(JSON.stringify({ error: 'Invalid request' }), {
-        status: 400,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-  });
-};
--- a/ts/servertools/tools.sslredirect.ts
+++ b/ts/servertools/tools.sslredirect.ts
@@ -1,22 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Server } from './classes.server.js';
-import { Handler } from './classes.handler.js';
-
-export const redirectFrom80To443 = async () => {
-  const smartexpressInstance = new Server({
-    cors: true,
-    forceSsl: true,
-    port: 80,
-  });
-
-  smartexpressInstance.addRoute(
-    '/{*splat}',
-    new Handler('ALL', async (req, res) => {
-      res.redirect('https://' + req.headers.host + req.url);
-    })
-  );
-
-  await smartexpressInstance.start();
-
-  return smartexpressInstance;
-};
--- a/ts/utilityservers/classes.websiteserver.ts
+++ b/ts/utilityservers/classes.websiteserver.ts
@@ -1,7 +1,6 @@
 import * as interfaces from '../../dist_ts_interfaces/index.js';
 import { type IServerOptions, TypedServer } from '../classes.typedserver.js';
 import * as plugins from '../plugins.js';
-import * as servertools from '../servertools/index.js';

 export interface IUtilityWebsiteServerConstructorOptions {
  addCustomRoutes?: (typedserver: TypedServer) => Promise<any>;
@@ -59,10 +58,12 @@ export class UtilityWebsiteServer {
      appSemVer: this.options.appSemVer || 'x.x.x',
    };

-    // -> /lsw* - anything regarding serviceworker
-    servertools.serviceworker.addServiceWorkerRoute(this.typedserver, () => {
-      return lswData;
-    });
+    // -> Service worker version info handler
+    this.typedserver.typedrouter.addTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>(
+      new plugins.typedrequest.TypedHandler('serviceworker_versionInfo', async () => {
+        return lswData;
+      })
+    );

    // ads.txt handler
    this.typedserver.addRoute('/ads.txt', 'GET', async () => {
--- a/ts_interfaces/serviceworker.ts
+++ b/ts_interfaces/serviceworker.ts
@@ -386,6 +386,7 @@ export interface IRequest_Serviceworker_GetEventLog
    limit?: number;
    type?: TEventType;
    since?: number;
+    before?: number;  // For pagination: get events before this timestamp
  };
  response: {
    events: IEventLogEntry[];
@@ -436,4 +437,205 @@ export interface IRequest_Serviceworker_GetEventCount
  response: {
    count: number;
  };
-}
+}
+
+// ===============
+// Push message interfaces (SW → Clients via DeesComms)
+// ===============
+
+/**
+ * Push notification when a new event is logged
+ * Sent via DeesComms BroadcastChannel
+ */
+export interface IMessage_Serviceworker_EventLogged
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IMessage_Serviceworker_EventLogged
+  > {
+  method: 'serviceworker_eventLogged';
+  request: IEventLogEntry;
+  response: {};
+}
+
+/**
+ * Metrics snapshot for push updates
+ */
+export interface IMetricsSnapshot {
+  cache: {
+    hits: number;
+    misses: number;
+    errors: number;
+    bytesServedFromCache: number;
+    bytesFetched: number;
+  };
+  network: {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+  };
+  cacheHitRate: number;
+  networkSuccessRate: number;
+  resourceCount: number;
+  uptime: number;
+  timestamp: number;
+}
+
+/**
+ * Push notification for metrics updates
+ * Sent via DeesComms BroadcastChannel (throttled)
+ */
+export interface IMessage_Serviceworker_MetricsUpdate
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IMessage_Serviceworker_MetricsUpdate
+  > {
+  method: 'serviceworker_metricsUpdate';
+  request: IMetricsSnapshot;
+  response: {};
+}
+
+/**
+ * Push notification when a new resource is cached
+ */
+export interface IMessage_Serviceworker_ResourceCached
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IMessage_Serviceworker_ResourceCached
+  > {
+  method: 'serviceworker_resourceCached';
+  request: {
+    url: string;
+    contentType: string;
+    size: number;
+    cached: boolean;
+  };
+  response: {};
+}
+
+// =============================
+// TypedRequest Traffic Monitoring
+// =============================
+
+/**
+ * Log entry for TypedRequest traffic monitoring
+ */
+export interface ITypedRequestLogEntry {
+  correlationId: string;
+  method: string;
+  direction: 'outgoing' | 'incoming';
+  phase: 'request' | 'response';
+  timestamp: number;
+  durationMs?: number;
+  payload: any;
+  error?: string;
+}
+
+/**
+ * Statistics for TypedRequest traffic
+ */
+export interface ITypedRequestStats {
+  totalRequests: number;
+  totalResponses: number;
+  methodCounts: Record<string, { requests: number; responses: number; errors: number; avgDurationMs: number }>;
+  errorCount: number;
+  avgDurationMs: number;
+}
+
+/**
+ * Message for logging TypedRequest traffic from client to SW
+ */
+export interface IMessage_Serviceworker_TypedRequestLog
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IMessage_Serviceworker_TypedRequestLog
+  > {
+  method: 'serviceworker_typedRequestLog';
+  request: ITypedRequestLogEntry;
+  response: {};
+}
+
+/**
+ * Push notification when a TypedRequest is logged
+ */
+export interface IMessage_Serviceworker_TypedRequestLogged
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IMessage_Serviceworker_TypedRequestLogged
+  > {
+  method: 'serviceworker_typedRequestLogged';
+  request: ITypedRequestLogEntry;
+  response: {};
+}
+
+/**
+ * Request to get TypedRequest logs
+ */
+export interface IRequest_Serviceworker_GetTypedRequestLogs
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_GetTypedRequestLogs
+  > {
+  method: 'serviceworker_getTypedRequestLogs';
+  request: {
+    limit?: number;
+    method?: string;
+    since?: number;
+    before?: number;  // For pagination: get logs before this timestamp
+  };
+  response: {
+    logs: ITypedRequestLogEntry[];
+    totalCount: number;
+  };
+}
+
+/**
+ * Request to get TypedRequest traffic statistics
+ */
+export interface IRequest_Serviceworker_GetTypedRequestStats
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_GetTypedRequestStats
+  > {
+  method: 'serviceworker_getTypedRequestStats';
+  request: {};
+  response: ITypedRequestStats;
+}
+
+/**
+ * Request to clear TypedRequest logs
+ */
+export interface IRequest_Serviceworker_ClearTypedRequestLogs
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_ClearTypedRequestLogs
+  > {
+  method: 'serviceworker_clearTypedRequestLogs';
+  request: {};
+  response: {
+    success: boolean;
+  };
+}
+
+// =============================
+// Shared Constants
+// =============================
+
+/**
+ * HTML shell for the SW Dashboard - shared between server and service worker
+ */
+export const SW_DASH_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>SW Dashboard</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { background: #0a0a0a; min-height: 100vh; }
+  </style>
+</head>
+<body>
+  <sw-dash-app></sw-dash-app>
+  <script type="module" src="/sw-dash/bundle.js"></script>
+</body>
+</html>`;
--- a/ts_swdash/plugins.ts
+++ b/ts_swdash/plugins.ts
@@ -3,6 +3,9 @@ import { LitElement, html, css } from 'lit';
 import type { CSSResult, TemplateResult } from 'lit';
 import { customElement, property, state } from 'lit/decorators.js';

+// DeesComms for push communication
+import * as deesComms from '@design.estate/dees-comms';
+
 export {
  LitElement,
  html,
@@ -10,6 +13,7 @@ export {
  customElement,
  property,
  state,
+  deesComms,
 };

 export type { CSSResult, TemplateResult };
--- a/ts_swdash/sw-dash-app.ts
+++ b/ts_swdash/sw-dash-app.ts
@@ -1,10 +1,11 @@
-import { LitElement, html, css, state, customElement } from './plugins.js';
+import { LitElement, html, css, state, customElement, deesComms } from './plugins.js';
 import type { CSSResult, TemplateResult } from './plugins.js';
 import { sharedStyles, terminalStyles, navStyles } from './sw-dash-styles.js';
 import type { IMetricsData } from './sw-dash-overview.js';
 import type { ICachedResource } from './sw-dash-urls.js';
 import type { IDomainStats } from './sw-dash-domains.js';
 import type { IContentTypeStats } from './sw-dash-types.js';
+import type { serviceworker } from '../dist_ts_interfaces/index.js';

 // Import components to register them
 import './sw-dash-overview.js';
@@ -12,9 +13,10 @@ import './sw-dash-urls.js';
 import './sw-dash-domains.js';
 import './sw-dash-types.js';
 import './sw-dash-events.js';
+import './sw-dash-requests.js';
 import './sw-dash-table.js';

-type ViewType = 'overview' | 'urls' | 'domains' | 'types' | 'events';
+type ViewType = 'overview' | 'urls' | 'domains' | 'types' | 'events' | 'requests';

 interface IResourceData {
  resources: ICachedResource[];
@@ -25,6 +27,11 @@ interface IResourceData {

 /**
 * Main SW Dashboard application shell
+ *
+ * Architecture:
+ * - ONE initial HTTP seed request to /sw-dash/metrics (provides ALL data)
+ * - HTTP heartbeat every 30s for SW health check
+ * - Everything else via DeesComms (push from SW, requests to SW)
 */
@customElement('sw-dash-app')
 export class SwDashApp extends LitElement {
@@ -125,67 +132,344 @@ export class SwDashApp extends LitElement {
    `
  ];

+  // Core metrics
  @state() accessor currentView: ViewType = 'overview';
  @state() accessor metrics: IMetricsData | null = null;
+  @state() accessor lastRefresh = new Date().toLocaleTimeString();
+  @state() accessor isConnected = false;
+
+  // Resource data (from initial seed)
  @state() accessor resourceData: IResourceData = {
    resources: [],
    domains: [],
    contentTypes: [],
    resourceCount: 0
  };
-  @state() accessor lastRefresh = new Date().toLocaleTimeString();

-  private refreshInterval: ReturnType<typeof setInterval> | null = null;
+  // Events data (from initial seed + push updates)
+  @state() accessor events: serviceworker.IEventLogEntry[] = [];
+  @state() accessor eventTotalCount = 0;
+  @state() accessor eventCountLastHour = 0;
+
+  // Request logs data (from initial seed + push updates)
+  @state() accessor requestLogs: serviceworker.ITypedRequestLogEntry[] = [];
+  @state() accessor requestTotalCount = 0;
+  @state() accessor requestStats: serviceworker.ITypedRequestStats | null = null;
+  @state() accessor requestMethods: string[] = [];
+
+  // DeesComms for communication with service worker
+  private comms: deesComms.DeesComms | null = null;
+
+  // Heartbeat interval (30 seconds) for SW health check
+  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+  private readonly HEARTBEAT_INTERVAL_MS = 30000;

  connectedCallback(): void {
    super.connectedCallback();
-    this.loadMetrics();
-    this.loadResourceData();
-    // Auto-refresh every 2 seconds
-    this.refreshInterval = setInterval(() => {
-      this.loadMetrics();
-      if (this.currentView !== 'overview') {
-        this.loadResourceData();
-      }
-    }, 2000);
+    // Initial HTTP seed request to wake up SW and get ALL initial data
+    this.loadInitialData();
+    // Setup push listeners via DeesComms
+    this.setupPushListeners();
+    // Start heartbeat for SW health check
+    this.startHeartbeat();
  }

  disconnectedCallback(): void {
    super.disconnectedCallback();
-    if (this.refreshInterval) {
-      clearInterval(this.refreshInterval);
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
    }
  }

-  private async loadMetrics(): Promise<void> {
+  /**
+   * Initial HTTP request to seed ALL data and wake up service worker
+   * This is the ONE HTTP request that provides everything:
+   * - Core metrics
+   * - Resources, domains, content types
+   * - Events (initial 50)
+   * - Request logs (initial 50), stats, methods
+   */
+  private async loadInitialData(): Promise<void> {
    try {
      const response = await fetch('/sw-dash/metrics');
-      this.metrics = await response.json();
+      const data = await response.json();
+
+      // Core metrics
+      this.metrics = data;
+
+      // Resource data
+      this.resourceData = {
+        resources: data.resources || [],
+        domains: data.domains || [],
+        contentTypes: data.contentTypes || [],
+        resourceCount: data.resourceCount || 0,
+      };
+
+      // Events data
+      this.events = data.events || [];
+      this.eventTotalCount = data.eventTotalCount || 0;
+      this.eventCountLastHour = data.eventCountLastHour || 0;
+
+      // Request logs data
+      this.requestLogs = data.requestLogs || [];
+      this.requestTotalCount = data.requestTotalCount || 0;
+      this.requestStats = data.requestStats || null;
+      this.requestMethods = data.requestMethods || [];
+
      this.lastRefresh = new Date().toLocaleTimeString();
+      this.isConnected = true;
    } catch (err) {
-      console.error('Failed to load metrics:', err);
+      console.error('Failed to load initial data:', err);
+      this.isConnected = false;
    }
  }

-  private async loadResourceData(): Promise<void> {
+  /**
+   * Setup DeesComms handlers for receiving push updates from SW
+   * All real-time updates come through here
+   */
+  private setupPushListeners(): void {
+    this.comms = new deesComms.DeesComms();
+
+    // Handle metrics push updates
+    this.comms.createTypedHandler<serviceworker.IMessage_Serviceworker_MetricsUpdate>(
+      'serviceworker_metricsUpdate',
+      async (snapshot) => {
+        // Update metrics from push
+        if (this.metrics) {
+          this.metrics = {
+            ...this.metrics,
+            cache: {
+              ...this.metrics.cache,
+              hits: snapshot.cache.hits,
+              misses: snapshot.cache.misses,
+              errors: snapshot.cache.errors,
+              bytesServedFromCache: snapshot.cache.bytesServedFromCache,
+              bytesFetched: snapshot.cache.bytesFetched,
+            },
+            network: {
+              ...this.metrics.network,
+              totalRequests: snapshot.network.totalRequests,
+              successfulRequests: snapshot.network.successfulRequests,
+              failedRequests: snapshot.network.failedRequests,
+            },
+            cacheHitRate: snapshot.cacheHitRate,
+            networkSuccessRate: snapshot.networkSuccessRate,
+            resourceCount: snapshot.resourceCount,
+            uptime: snapshot.uptime,
+          };
+        }
+        this.lastRefresh = new Date().toLocaleTimeString();
+        this.isConnected = true;
+        return {};
+      }
+    );
+
+    // Handle new event logged - add to our events array
+    this.comms.createTypedHandler<serviceworker.IMessage_Serviceworker_EventLogged>(
+      'serviceworker_eventLogged',
+      async (entry) => {
+        // Prepend new event to array
+        this.events = [entry, ...this.events];
+        this.eventTotalCount++;
+        // Check if event is within last hour
+        const oneHourAgo = Date.now() - 3600000;
+        if (entry.timestamp >= oneHourAgo) {
+          this.eventCountLastHour++;
+        }
+        return {};
+      }
+    );
+
+    // Handle resource cached push updates
+    this.comms.createTypedHandler<serviceworker.IMessage_Serviceworker_ResourceCached>(
+      'serviceworker_resourceCached',
+      async (resource) => {
+        // Update resource count optimistically
+        if (resource.cached && this.metrics) {
+          this.metrics = {
+            ...this.metrics,
+            resourceCount: this.metrics.resourceCount + 1,
+          };
+        }
+        return {};
+      }
+    );
+
+    // Handle new TypedRequest logged - add to our logs array
+    this.comms.createTypedHandler<serviceworker.IMessage_Serviceworker_TypedRequestLogged>(
+      'serviceworker_typedRequestLogged',
+      async (entry) => {
+        // Prepend new log to array
+        this.requestLogs = [entry, ...this.requestLogs];
+        this.requestTotalCount++;
+
+        // Update stats optimistically
+        if (this.requestStats) {
+          const newStats = { ...this.requestStats };
+          if (entry.phase === 'request') {
+            newStats.totalRequests++;
+          } else {
+            newStats.totalResponses++;
+          }
+          if (entry.error) {
+            newStats.errorCount++;
+          }
+          // Update method counts
+          if (!newStats.methodCounts[entry.method]) {
+            newStats.methodCounts[entry.method] = { requests: 0, responses: 0, errors: 0, avgDurationMs: 0 };
+            // Add to methods list if new
+            if (!this.requestMethods.includes(entry.method)) {
+              this.requestMethods = [...this.requestMethods, entry.method];
+            }
+          }
+          if (entry.phase === 'request') {
+            newStats.methodCounts[entry.method].requests++;
+          } else {
+            newStats.methodCounts[entry.method].responses++;
+          }
+          if (entry.error) {
+            newStats.methodCounts[entry.method].errors++;
+          }
+          this.requestStats = newStats;
+        }
+        return {};
+      }
+    );
+  }
+
+  /**
+   * Heartbeat to check SW health periodically (HTTP)
+   * This is the ONLY periodic HTTP request
+   */
+  private startHeartbeat(): void {
+    this.heartbeatInterval = setInterval(async () => {
+      try {
+        const response = await fetch('/sw-dash/metrics');
+        if (response.ok) {
+          this.isConnected = true;
+          // Refresh all data from heartbeat response
+          const data = await response.json();
+          this.metrics = data;
+          this.resourceData = {
+            resources: data.resources || [],
+            domains: data.domains || [],
+            contentTypes: data.contentTypes || [],
+            resourceCount: data.resourceCount || 0,
+          };
+          this.events = data.events || [];
+          this.eventTotalCount = data.eventTotalCount || 0;
+          this.eventCountLastHour = data.eventCountLastHour || 0;
+          this.requestLogs = data.requestLogs || [];
+          this.requestTotalCount = data.requestTotalCount || 0;
+          this.requestStats = data.requestStats || null;
+          this.requestMethods = data.requestMethods || [];
+          this.lastRefresh = new Date().toLocaleTimeString();
+        } else {
+          this.isConnected = false;
+        }
+      } catch {
+        this.isConnected = false;
+      }
+    }, this.HEARTBEAT_INTERVAL_MS);
+  }
+
+  /**
+   * Handle "load more events" request from sw-dash-events component
+   * Uses DeesComms to request older events from SW
+   */
+  private async handleLoadMoreEvents(e: CustomEvent<{ before: number }>): Promise<void> {
+    if (!this.comms) return;
+
    try {
-      const response = await fetch('/sw-dash/resources');
-      this.resourceData = await response.json();
+      const tr = this.comms.createTypedRequest<serviceworker.IRequest_Serviceworker_GetEventLog>('serviceworker_getEventLog');
+      const result = await tr.fire({
+        limit: 50,
+        before: e.detail.before,
+      });
+      // Append older events to existing array
+      this.events = [...this.events, ...result.events];
+      this.eventTotalCount = result.totalCount;
    } catch (err) {
-      console.error('Failed to load resources:', err);
+      console.error('Failed to load more events:', err);
+    }
+  }
+
+  /**
+   * Handle "clear events" request from sw-dash-events component
+   * Uses DeesComms to clear event log in SW
+   */
+  private async handleClearEvents(): Promise<void> {
+    if (!this.comms) return;
+
+    try {
+      const tr = this.comms.createTypedRequest<serviceworker.IRequest_Serviceworker_ClearEventLog>('serviceworker_clearEventLog');
+      await tr.fire({});
+      // Clear local state
+      this.events = [];
+      this.eventTotalCount = 0;
+      this.eventCountLastHour = 0;
+    } catch (err) {
+      console.error('Failed to clear events:', err);
+    }
+  }
+
+  /**
+   * Handle "load more requests" from sw-dash-requests component
+   * Uses DeesComms to request older request logs from SW
+   */
+  private async handleLoadMoreRequests(e: CustomEvent<{ before: number; method?: string }>): Promise<void> {
+    if (!this.comms) return;
+
+    try {
+      const tr = this.comms.createTypedRequest<serviceworker.IRequest_Serviceworker_GetTypedRequestLogs>('serviceworker_getTypedRequestLogs');
+      const result = await tr.fire({
+        limit: 50,
+        before: e.detail.before,
+        method: e.detail.method,
+      });
+      // Append older logs to existing array
+      this.requestLogs = [...this.requestLogs, ...result.logs];
+      this.requestTotalCount = result.totalCount;
+    } catch (err) {
+      console.error('Failed to load more requests:', err);
+    }
+  }
+
+  /**
+   * Handle "clear requests" from sw-dash-requests component
+   * Uses DeesComms to clear request logs in SW
+   */
+  private async handleClearRequests(): Promise<void> {
+    if (!this.comms) return;
+
+    try {
+      const tr = this.comms.createTypedRequest<serviceworker.IRequest_Serviceworker_ClearTypedRequestLogs>('serviceworker_clearTypedRequestLogs');
+      await tr.fire({});
+      // Clear local state
+      this.requestLogs = [];
+      this.requestTotalCount = 0;
+      this.requestStats = {
+        totalRequests: 0,
+        totalResponses: 0,
+        methodCounts: {},
+        errorCount: 0,
+        avgDurationMs: 0,
+      };
+      this.requestMethods = [];
+    } catch (err) {
+      console.error('Failed to clear requests:', err);
    }
  }

  private setView(view: ViewType): void {
    this.currentView = view;
-    if (view !== 'overview') {
-      this.loadResourceData();
-    }
+    // No HTTP fetch on view change - data is already loaded from initial seed
  }

  private handleSpeedtestComplete(_e: CustomEvent): void {
-    // Refresh metrics after speedtest
-    this.loadMetrics();
+    // Refresh metrics after speedtest via HTTP
+    this.loadInitialData();
  }

  private formatUptime(ms: number): string {
@@ -233,12 +517,17 @@ export class SwDashApp extends LitElement {
            class="nav-tab ${this.currentView === 'events' ? 'active' : ''}"
            @click="${() => this.setView('events')}"
          >Events</button>
+          <button
+            class="nav-tab ${this.currentView === 'requests' ? 'active' : ''}"
+            @click="${() => this.setView('requests')}"
+          >Requests</button>
        </nav>

        <div class="content">
          <div class="view ${this.currentView === 'overview' ? 'active' : ''}">
            <sw-dash-overview
              .metrics="${this.metrics}"
+              .eventCountLastHour="${this.eventCountLastHour}"
              @speedtest-complete="${this.handleSpeedtestComplete}"
            ></sw-dash-overview>
          </div>
@@ -256,7 +545,23 @@ export class SwDashApp extends LitElement {
          </div>

          <div class="view ${this.currentView === 'events' ? 'active' : ''}">
-            <sw-dash-events></sw-dash-events>
+            <sw-dash-events
+              .events="${this.events}"
+              .totalCount="${this.eventTotalCount}"
+              @load-more-events="${this.handleLoadMoreEvents}"
+              @clear-events="${this.handleClearEvents}"
+            ></sw-dash-events>
+          </div>
+
+          <div class="view ${this.currentView === 'requests' ? 'active' : ''}">
+            <sw-dash-requests
+              .logs="${this.requestLogs}"
+              .totalCount="${this.requestTotalCount}"
+              .stats="${this.requestStats}"
+              .methods="${this.requestMethods}"
+              @load-more-requests="${this.handleLoadMoreRequests}"
+              @clear-requests="${this.handleClearRequests}"
+            ></sw-dash-requests>
          </div>
        </div>

--- a/ts_swdash/sw-dash-events.ts
+++ b/ts_swdash/sw-dash-events.ts
@@ -18,6 +18,10 @@ type TEventFilter = 'all' | 'sw_installed' | 'sw_activated' | 'sw_updated' | 'sw

 /**
 * Events panel component for sw-dash
+ *
+ * Receives events via property from parent (sw-dash-app).
+ * Filtering is done locally.
+ * Load more and clear operations dispatch events to parent.
 */
@customElement('sw-dash-events')
 export class SwDashEvents extends LitElement {
@@ -189,64 +193,52 @@ export class SwDashEvents extends LitElement {
    `
  ];

+  // Received from parent (sw-dash-app)
  @property({ type: Array }) accessor events: IEventLogEntry[] = [];
+  @property({ type: Number }) accessor totalCount = 0;
+
+  // Local state for filtering
  @state() accessor filter: TEventFilter = 'all';
  @state() accessor searchText = '';
-  @state() accessor totalCount = 0;
-  @state() accessor isLoading = true;
-  @state() accessor page = 1;
-  private readonly pageSize = 50;
-
-  connectedCallback(): void {
-    super.connectedCallback();
-    this.loadEvents();
-  }
-
-  private async loadEvents(): Promise<void> {
-    this.isLoading = true;
-    try {
-      const params = new URLSearchParams();
-      params.set('limit', String(this.pageSize * this.page));
-      if (this.filter !== 'all') {
-        params.set('type', this.filter);
-      }
-
-      const response = await fetch(`/sw-dash/events?${params}`);
-      const data = await response.json();
-      this.events = data.events;
-      this.totalCount = data.totalCount;
-    } catch (err) {
-      console.error('Failed to load events:', err);
-    } finally {
-      this.isLoading = false;
-    }
-  }
+  @state() accessor isLoadingMore = false;

  private handleFilterChange(e: Event): void {
    this.filter = (e.target as HTMLSelectElement).value as TEventFilter;
-    this.page = 1;
-    this.loadEvents();
+    // Local filtering - no HTTP request
  }

  private handleSearch(e: Event): void {
    this.searchText = (e.target as HTMLInputElement).value.toLowerCase();
  }

-  private async handleClear(): Promise<void> {
+  private handleClear(): void {
    if (!confirm('Are you sure you want to clear the event log? This cannot be undone.')) {
      return;
    }
-    try {
-      await fetch('/sw-dash/events', { method: 'DELETE' });
-      this.loadEvents();
-    } catch (err) {
-      console.error('Failed to clear events:', err);
-    }
+    // Dispatch event to parent to clear via DeesComms
+    this.dispatchEvent(new CustomEvent('clear-events', {
+      bubbles: true,
+      composed: true,
+    }));
  }

  private loadMore(): void {
-    this.page++;
-    this.loadEvents();
+    if (this.isLoadingMore || this.events.length === 0) return;
+
+    this.isLoadingMore = true;
+    const oldestEvent = this.events[this.events.length - 1];
+
+    // Dispatch event to parent to load more via DeesComms
+    this.dispatchEvent(new CustomEvent('load-more-events', {
+      detail: { before: oldestEvent.timestamp },
+      bubbles: true,
+      composed: true,
+    }));
+
+    // Reset loading state after a short delay (parent will update events prop)
+    setTimeout(() => {
+      this.isLoadingMore = false;
+    }, 1000);
  }

  private getTypeClass(type: string): string {
@@ -267,13 +259,27 @@ export class SwDashEvents extends LitElement {
    return type.replace(/_/g, ' ');
  }

+  /**
+   * Filter events locally based on type and search text
+   */
  private getFilteredEvents(): IEventLogEntry[] {
-    if (!this.searchText) return this.events;
-    return this.events.filter(e =>
-      e.message.toLowerCase().includes(this.searchText) ||
-      e.type.toLowerCase().includes(this.searchText) ||
-      (e.details && JSON.stringify(e.details).toLowerCase().includes(this.searchText))
-    );
+    let result = this.events;
+
+    // Filter by type
+    if (this.filter !== 'all') {
+      result = result.filter(e => e.type === this.filter);
+    }
+
+    // Filter by search text
+    if (this.searchText) {
+      result = result.filter(e =>
+        e.message.toLowerCase().includes(this.searchText) ||
+        e.type.toLowerCase().includes(this.searchText) ||
+        (e.details && JSON.stringify(e.details).toLowerCase().includes(this.searchText))
+      );
+    }
+
+    return result;
  }

  public render(): TemplateResult {
@@ -319,10 +325,10 @@ export class SwDashEvents extends LitElement {
        <button class="btn clear-btn" @click="${this.handleClear}">Clear Log</button>
      </div>

-      ${this.isLoading && this.events.length === 0 ? html`
-        <div class="empty-state">Loading events...</div>
+      ${this.events.length === 0 ? html`
+        <div class="empty-state">No events recorded</div>
      ` : filteredEvents.length === 0 ? html`
-        <div class="empty-state">No events found</div>
+        <div class="empty-state">No events match filter</div>
      ` : html`
        <div class="events-list">
          ${filteredEvents.map(event => html`
@@ -341,8 +347,8 @@ export class SwDashEvents extends LitElement {

        ${this.events.length < this.totalCount ? html`
          <div class="pagination">
-            <button class="btn btn-secondary" @click="${this.loadMore}" ?disabled="${this.isLoading}">
-              ${this.isLoading ? 'Loading...' : 'Load More'}
+            <button class="btn btn-secondary" @click="${this.loadMore}" ?disabled="${this.isLoadingMore}">
+              ${this.isLoadingMore ? 'Loading...' : 'Load More'}
            </button>
            <span class="page-info">${this.events.length} of ${this.totalCount} events</span>
          </div>
--- a/ts_swdash/sw-dash-overview.ts
+++ b/ts_swdash/sw-dash-overview.ts
@@ -79,42 +79,15 @@ export class SwDashOverview extends LitElement {
  ];

  @property({ type: Object }) accessor metrics: IMetricsData | null = null;
+  @property({ type: Number }) accessor eventCountLastHour = 0;
  @state() accessor speedtestRunning = false;
  @state() accessor speedtestPhase: 'idle' | 'latency' | 'download' | 'upload' | 'complete' = 'idle';
  @state() accessor speedtestProgress = 0;
  @state() accessor speedtestElapsed = 0;
-  @state() accessor eventCountLastHour = 0;

  // Speedtest timing constants (must match service worker)
  private static readonly TEST_DURATION_MS = 5000;  // 5 seconds per test
  private progressInterval: number | null = null;
-  private eventCountInterval: number | null = null;
-
-  connectedCallback(): void {
-    super.connectedCallback();
-    this.fetchEventCount();
-    // Refresh event count every 30 seconds
-    this.eventCountInterval = window.setInterval(() => this.fetchEventCount(), 30000);
-  }
-
-  disconnectedCallback(): void {
-    super.disconnectedCallback();
-    if (this.eventCountInterval) {
-      window.clearInterval(this.eventCountInterval);
-      this.eventCountInterval = null;
-    }
-  }
-
-  private async fetchEventCount(): Promise<void> {
-    try {
-      const oneHourAgo = Date.now() - 3600000;
-      const response = await fetch(`/sw-dash/events/count?since=${oneHourAgo}`);
-      const data = await response.json();
-      this.eventCountLastHour = data.count;
-    } catch (err) {
-      console.error('Failed to fetch event count:', err);
-    }
-  }

  private async runSpeedtest(): Promise<void> {
    if (this.speedtestRunning) return;
--- a/ts_swdash/sw-dash-requests.ts
+++ b/ts_swdash/sw-dash-requests.ts
@@ -0,0 +1,581 @@
+import { LitElement, html, css, property, state, customElement } from './plugins.js';
+import type { CSSResult, TemplateResult } from './plugins.js';
+import { sharedStyles, panelStyles, tableStyles, buttonStyles } from './sw-dash-styles.js';
+
+export interface ITypedRequestLogEntry {
+  correlationId: string;
+  method: string;
+  direction: 'outgoing' | 'incoming';
+  phase: 'request' | 'response';
+  timestamp: number;
+  durationMs?: number;
+  payload: any;
+  error?: string;
+}
+
+export interface ITypedRequestStats {
+  totalRequests: number;
+  totalResponses: number;
+  methodCounts: Record<string, { requests: number; responses: number; errors: number; avgDurationMs: number }>;
+  errorCount: number;
+  avgDurationMs: number;
+}
+
+type TRequestFilter = 'all' | 'outgoing' | 'incoming';
+type TPhaseFilter = 'all' | 'request' | 'response';
+
+/**
+ * TypedRequest traffic monitoring panel for sw-dash
+ *
+ * Receives logs, stats, and methods via properties from parent (sw-dash-app).
+ * Filtering is done locally.
+ * Load more and clear operations dispatch events to parent.
+ */
+@customElement('sw-dash-requests')
+export class SwDashRequests extends LitElement {
+  public static styles: CSSResult[] = [
+    sharedStyles,
+    panelStyles,
+    tableStyles,
+    buttonStyles,
+    css`
+      :host {
+        display: block;
+      }
+
+      .requests-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: var(--space-4);
+        gap: var(--space-3);
+        flex-wrap: wrap;
+      }
+
+      .filter-group {
+        display: flex;
+        align-items: center;
+        gap: var(--space-2);
+      }
+
+      .filter-label {
+        font-size: 12px;
+        color: var(--text-tertiary);
+      }
+
+      .filter-select {
+        background: var(--bg-secondary);
+        border: 1px solid var(--border-default);
+        border-radius: var(--radius-sm);
+        padding: var(--space-1) var(--space-2);
+        color: var(--text-primary);
+        font-size: 12px;
+      }
+
+      .filter-select:focus {
+        outline: none;
+        border-color: var(--accent-primary);
+      }
+
+      .requests-list {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-2);
+        max-height: 600px;
+        overflow-y: auto;
+      }
+
+      .request-card {
+        background: var(--bg-secondary);
+        border: 1px solid var(--border-default);
+        border-radius: var(--radius-md);
+        padding: var(--space-3);
+      }
+
+      .request-card.has-error {
+        border-color: var(--accent-error);
+      }
+
+      .request-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: flex-start;
+        margin-bottom: var(--space-2);
+        gap: var(--space-2);
+      }
+
+      .request-badges {
+        display: flex;
+        gap: var(--space-2);
+        align-items: center;
+        flex-wrap: wrap;
+      }
+
+      .badge {
+        display: inline-flex;
+        align-items: center;
+        padding: var(--space-1) var(--space-2);
+        border-radius: var(--radius-sm);
+        font-size: 11px;
+        font-weight: 500;
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+      }
+
+      .badge.direction-outgoing { background: rgba(59, 130, 246, 0.15); color: #3b82f6; }
+      .badge.direction-incoming { background: rgba(34, 197, 94, 0.15); color: var(--accent-success); }
+      .badge.phase-request { background: rgba(251, 191, 36, 0.15); color: var(--accent-warning); }
+      .badge.phase-response { background: rgba(99, 102, 241, 0.15); color: var(--accent-primary); }
+      .badge.error { background: rgba(239, 68, 68, 0.15); color: var(--accent-error); }
+
+      .method-name {
+        font-size: 13px;
+        font-weight: 600;
+        color: var(--text-primary);
+        font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+      }
+
+      .request-meta {
+        display: flex;
+        gap: var(--space-3);
+        align-items: center;
+        font-size: 11px;
+        color: var(--text-tertiary);
+      }
+
+      .request-time {
+        font-variant-numeric: tabular-nums;
+      }
+
+      .request-duration {
+        color: var(--accent-success);
+      }
+
+      .request-duration.slow {
+        color: var(--accent-warning);
+      }
+
+      .request-duration.very-slow {
+        color: var(--accent-error);
+      }
+
+      .request-payload {
+        font-size: 11px;
+        color: var(--text-tertiary);
+        background: var(--bg-tertiary);
+        padding: var(--space-2);
+        border-radius: var(--radius-sm);
+        font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+        white-space: pre-wrap;
+        word-break: break-all;
+        max-height: 150px;
+        overflow-y: auto;
+        margin-top: var(--space-2);
+      }
+
+      .request-error {
+        font-size: 12px;
+        color: var(--accent-error);
+        background: rgba(239, 68, 68, 0.1);
+        padding: var(--space-2);
+        border-radius: var(--radius-sm);
+        margin-top: var(--space-2);
+      }
+
+      .stats-bar {
+        display: flex;
+        gap: var(--space-4);
+        margin-bottom: var(--space-4);
+        padding: var(--space-3);
+        background: var(--bg-secondary);
+        border-radius: var(--radius-md);
+        border: 1px solid var(--border-default);
+        flex-wrap: wrap;
+      }
+
+      .stat-item {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-1);
+      }
+
+      .stat-value {
+        font-size: 18px;
+        font-weight: 600;
+        color: var(--text-primary);
+        font-variant-numeric: tabular-nums;
+      }
+
+      .stat-value.error {
+        color: var(--accent-error);
+      }
+
+      .stat-label {
+        font-size: 11px;
+        color: var(--text-tertiary);
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+      }
+
+      .method-stats {
+        margin-bottom: var(--space-4);
+      }
+
+      .method-stats-title {
+        font-size: 12px;
+        font-weight: 500;
+        color: var(--text-secondary);
+        margin-bottom: var(--space-2);
+      }
+
+      .method-stats-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+        gap: var(--space-2);
+      }
+
+      .method-stat-card {
+        background: var(--bg-tertiary);
+        border-radius: var(--radius-sm);
+        padding: var(--space-2);
+      }
+
+      .method-stat-name {
+        font-size: 11px;
+        font-weight: 500;
+        color: var(--text-primary);
+        font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+        margin-bottom: var(--space-1);
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .method-stat-details {
+        display: flex;
+        gap: var(--space-3);
+        font-size: 10px;
+        color: var(--text-tertiary);
+      }
+
+      .empty-state {
+        text-align: center;
+        padding: var(--space-6);
+        color: var(--text-tertiary);
+      }
+
+      .clear-btn {
+        background: rgba(239, 68, 68, 0.1);
+        color: var(--accent-error);
+        border: 1px solid transparent;
+      }
+
+      .clear-btn:hover {
+        background: rgba(239, 68, 68, 0.2);
+        border-color: var(--accent-error);
+      }
+
+      .pagination {
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        gap: var(--space-2);
+        margin-top: var(--space-4);
+      }
+
+      .page-info {
+        font-size: 12px;
+        color: var(--text-tertiary);
+      }
+
+      .toggle-payload {
+        font-size: 11px;
+        color: var(--accent-primary);
+        cursor: pointer;
+        margin-top: var(--space-1);
+      }
+
+      .toggle-payload:hover {
+        text-decoration: underline;
+      }
+
+      .correlation-id {
+        font-size: 10px;
+        color: var(--text-tertiary);
+        font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+      }
+    `
+  ];
+
+  // Received from parent (sw-dash-app)
+  @property({ type: Array }) accessor logs: ITypedRequestLogEntry[] = [];
+  @property({ type: Number }) accessor totalCount = 0;
+  @property({ type: Object }) accessor stats: ITypedRequestStats | null = null;
+  @property({ type: Array }) accessor methods: string[] = [];
+
+  // Local state for filtering
+  @state() accessor directionFilter: TRequestFilter = 'all';
+  @state() accessor phaseFilter: TPhaseFilter = 'all';
+  @state() accessor methodFilter = '';
+  @state() accessor searchText = '';
+  @state() accessor expandedPayloads: Set<string> = new Set();
+  @state() accessor isLoadingMore = false;
+
+  private handleDirectionFilterChange(e: Event): void {
+    this.directionFilter = (e.target as HTMLSelectElement).value as TRequestFilter;
+    // Local filtering - no HTTP request
+  }
+
+  private handlePhaseFilterChange(e: Event): void {
+    this.phaseFilter = (e.target as HTMLSelectElement).value as TPhaseFilter;
+    // Local filtering - no HTTP request
+  }
+
+  private handleMethodFilterChange(e: Event): void {
+    this.methodFilter = (e.target as HTMLSelectElement).value;
+    // Local filtering - no HTTP request
+  }
+
+  private handleSearch(e: Event): void {
+    this.searchText = (e.target as HTMLInputElement).value.toLowerCase();
+  }
+
+  private handleClear(): void {
+    if (!confirm('Are you sure you want to clear the request logs? This cannot be undone.')) {
+      return;
+    }
+    // Dispatch event to parent to clear via DeesComms
+    this.dispatchEvent(new CustomEvent('clear-requests', {
+      bubbles: true,
+      composed: true,
+    }));
+  }
+
+  private loadMore(): void {
+    if (this.isLoadingMore || this.logs.length === 0) return;
+
+    this.isLoadingMore = true;
+    const oldestLog = this.logs[this.logs.length - 1];
+
+    // Dispatch event to parent to load more via DeesComms
+    this.dispatchEvent(new CustomEvent('load-more-requests', {
+      detail: {
+        before: oldestLog.timestamp,
+        method: this.methodFilter || undefined,
+      },
+      bubbles: true,
+      composed: true,
+    }));
+
+    // Reset loading state after a short delay (parent will update logs prop)
+    setTimeout(() => {
+      this.isLoadingMore = false;
+    }, 1000);
+  }
+
+  private togglePayload(correlationId: string): void {
+    const newSet = new Set(this.expandedPayloads);
+    if (newSet.has(correlationId)) {
+      newSet.delete(correlationId);
+    } else {
+      newSet.add(correlationId);
+    }
+    this.expandedPayloads = newSet;
+  }
+
+  private formatTimestamp(ts: number): string {
+    const date = new Date(ts);
+    return date.toLocaleTimeString(undefined, {
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      fractionalSecondDigits: 3
+    });
+  }
+
+  private getDurationClass(durationMs: number | undefined): string {
+    if (!durationMs) return '';
+    if (durationMs > 5000) return 'very-slow';
+    if (durationMs > 1000) return 'slow';
+    return '';
+  }
+
+  private formatDuration(durationMs: number | undefined): string {
+    if (!durationMs) return '';
+    if (durationMs < 1000) return `${durationMs}ms`;
+    return `${(durationMs / 1000).toFixed(2)}s`;
+  }
+
+  /**
+   * Filter logs locally based on direction, phase, method, and search text
+   */
+  private getFilteredLogs(): ITypedRequestLogEntry[] {
+    let result = this.logs;
+
+    // Apply direction filter
+    if (this.directionFilter !== 'all') {
+      result = result.filter(l => l.direction === this.directionFilter);
+    }
+
+    // Apply phase filter
+    if (this.phaseFilter !== 'all') {
+      result = result.filter(l => l.phase === this.phaseFilter);
+    }
+
+    // Apply method filter
+    if (this.methodFilter) {
+      result = result.filter(l => l.method === this.methodFilter);
+    }
+
+    // Apply search
+    if (this.searchText) {
+      result = result.filter(l =>
+        l.method.toLowerCase().includes(this.searchText) ||
+        l.correlationId.toLowerCase().includes(this.searchText) ||
+        (l.error && l.error.toLowerCase().includes(this.searchText)) ||
+        JSON.stringify(l.payload).toLowerCase().includes(this.searchText)
+      );
+    }
+
+    return result;
+  }
+
+  public render(): TemplateResult {
+    const filteredLogs = this.getFilteredLogs();
+
+    return html`
+      <!-- Stats Bar -->
+      <div class="stats-bar">
+        <div class="stat-item">
+          <span class="stat-value">${this.stats?.totalRequests ?? 0}</span>
+          <span class="stat-label">Total Requests</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">${this.stats?.totalResponses ?? 0}</span>
+          <span class="stat-label">Total Responses</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value ${(this.stats?.errorCount ?? 0) > 0 ? 'error' : ''}">${this.stats?.errorCount ?? 0}</span>
+          <span class="stat-label">Errors</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">${this.stats?.avgDurationMs ?? 0}ms</span>
+          <span class="stat-label">Avg Duration</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">${filteredLogs.length}</span>
+          <span class="stat-label">Showing</span>
+        </div>
+      </div>
+
+      <!-- Method Stats -->
+      ${this.stats && Object.keys(this.stats.methodCounts).length > 0 ? html`
+        <div class="method-stats">
+          <div class="method-stats-title">Methods</div>
+          <div class="method-stats-grid">
+            ${Object.entries(this.stats.methodCounts).slice(0, 8).map(([method, data]) => html`
+              <div class="method-stat-card">
+                <div class="method-stat-name" title="${method}">${method}</div>
+                <div class="method-stat-details">
+                  <span>${data.requests} req</span>
+                  <span>${data.responses} res</span>
+                  ${data.errors > 0 ? html`<span style="color: var(--accent-error)">${data.errors} err</span>` : ''}
+                  <span>${data.avgDurationMs}ms avg</span>
+                </div>
+              </div>
+            `)}
+          </div>
+        </div>
+      ` : ''}
+
+      <!-- Filters -->
+      <div class="requests-header">
+        <div class="filter-group">
+          <span class="filter-label">Direction:</span>
+          <select class="filter-select" @change="${this.handleDirectionFilterChange}">
+            <option value="all">All</option>
+            <option value="outgoing">Outgoing</option>
+            <option value="incoming">Incoming</option>
+          </select>
+
+          <span class="filter-label">Phase:</span>
+          <select class="filter-select" @change="${this.handlePhaseFilterChange}">
+            <option value="all">All</option>
+            <option value="request">Request</option>
+            <option value="response">Response</option>
+          </select>
+
+          <span class="filter-label">Method:</span>
+          <select class="filter-select" @change="${this.handleMethodFilterChange}">
+            <option value="">All Methods</option>
+            ${this.methods.map(m => html`<option value="${m}">${m}</option>`)}
+          </select>
+
+          <input
+            type="text"
+            class="search-input"
+            placeholder="Search..."
+            .value="${this.searchText}"
+            @input="${this.handleSearch}"
+            style="width: 150px;"
+          >
+        </div>
+        <button class="btn clear-btn" @click="${this.handleClear}">Clear Logs</button>
+      </div>
+
+      <!-- Request List -->
+      ${this.logs.length === 0 ? html`
+        <div class="empty-state">No request logs found. Traffic will appear here as TypedRequests are made.</div>
+      ` : filteredLogs.length === 0 ? html`
+        <div class="empty-state">No logs match filter</div>
+      ` : html`
+        <div class="requests-list">
+          ${filteredLogs.map(log => html`
+            <div class="request-card ${log.error ? 'has-error' : ''}">
+              <div class="request-header">
+                <div>
+                  <div class="request-badges">
+                    <span class="badge direction-${log.direction}">${log.direction}</span>
+                    <span class="badge phase-${log.phase}">${log.phase}</span>
+                    ${log.error ? html`<span class="badge error">error</span>` : ''}
+                  </div>
+                  <div class="method-name">${log.method}</div>
+                  <div class="correlation-id">${log.correlationId}</div>
+                </div>
+                <div class="request-meta">
+                  <span class="request-time">${this.formatTimestamp(log.timestamp)}</span>
+                  ${log.durationMs !== undefined ? html`
+                    <span class="request-duration ${this.getDurationClass(log.durationMs)}">
+                      ${this.formatDuration(log.durationMs)}
+                    </span>
+                  ` : ''}
+                </div>
+              </div>
+
+              ${log.error ? html`
+                <div class="request-error">${log.error}</div>
+              ` : ''}
+
+              <div class="toggle-payload" @click="${() => this.togglePayload(log.correlationId)}">
+                ${this.expandedPayloads.has(log.correlationId) ? 'Hide payload' : 'Show payload'}
+              </div>
+
+              ${this.expandedPayloads.has(log.correlationId) ? html`
+                <div class="request-payload">${JSON.stringify(log.payload, null, 2)}</div>
+              ` : ''}
+            </div>
+          `)}
+        </div>
+
+        ${this.logs.length < this.totalCount ? html`
+          <div class="pagination">
+            <button class="btn btn-secondary" @click="${this.loadMore}" ?disabled="${this.isLoadingMore}">
+              ${this.isLoadingMore ? 'Loading...' : 'Load More'}
+            </button>
+            <span class="page-info">${this.logs.length} of ${this.totalCount} logs</span>
+          </div>
+        ` : ''}
+      `}
+    `;
+  }
+}
--- a/ts_web_inject/index.ts
+++ b/ts_web_inject/index.ts
@@ -5,6 +5,9 @@ logger.log('info', `TypedServer-Devtools initialized!`);

 import { TypedserverStatusPill } from './typedserver_web.statuspill.js';

+// Import hook types from typedrequest
+type ITypedRequestLogEntry = plugins.typedrequest.ITypedRequestLogEntry;
+
 export class ReloadChecker {
  public reloadJustified = false;
  public backendConnectionLost = false;
@@ -18,6 +21,7 @@ export class ReloadChecker {
  public typedsocket: plugins.typedsocket.TypedSocket;
  public typedrouter = new plugins.typedrequest.TypedRouter();
  private swStatusUnsubscribe: (() => void) | null = null;
+  private trafficLoggingEnabled = false;

  constructor() {
    // Listen to browser online/offline events
@@ -240,6 +244,9 @@ export class ReloadChecker {
        }
      });
      logger.log('success', `ReloadChecker connected through typedsocket!`);
+
+      // Enable traffic logging for sw-dash
+      this.enableTrafficLogging();
    }
  }

@@ -268,6 +275,51 @@ export class ReloadChecker {
      this.swStatusUnsubscribe();
      this.swStatusUnsubscribe = null;
    }
+    // Clear global hooks when stopping
+    if (this.trafficLoggingEnabled) {
+      plugins.typedrequest.TypedRouter.clearGlobalHooks();
+      this.trafficLoggingEnabled = false;
+    }
+  }
+
+  /**
+   * Enable TypedRequest traffic logging to the service worker
+   * Sets up global hooks on TypedRouter to capture all request/response traffic
+   */
+  public enableTrafficLogging(): void {
+    if (this.trafficLoggingEnabled) {
+      logger.log('note', 'Traffic logging already enabled');
+      return;
+    }
+
+    // Check if service worker client is available
+    if (!globalThis.globalSw?.actionManager) {
+      logger.log('note', 'Service worker client not available, will retry traffic logging setup...');
+      setTimeout(() => this.enableTrafficLogging(), 2000);
+      return;
+    }
+
+    const actionManager = globalThis.globalSw.actionManager;
+
+    // Helper function to log entries
+    const logEntry = (entry: ITypedRequestLogEntry) => {
+      // Skip logging our own logging requests to avoid infinite loops
+      if (entry.method === 'serviceworker_typedRequestLog') {
+        return;
+      }
+      actionManager.logTypedRequest(entry);
+    };
+
+    // Set up global hooks on TypedRouter
+    plugins.typedrequest.TypedRouter.setGlobalHooks({
+      onOutgoingRequest: logEntry,
+      onIncomingResponse: logEntry,
+      onIncomingRequest: logEntry,
+      onOutgoingResponse: logEntry,
+    });
+
+    this.trafficLoggingEnabled = true;
+    logger.log('success', 'TypedRequest traffic logging enabled');
  }
 }

--- a/ts_web_serviceworker/classes.backend.ts
+++ b/ts_web_serviceworker/classes.backend.ts
@@ -4,6 +4,7 @@ import { logger } from './logging.js';
 import { getMetricsCollector } from './classes.metrics.js';
 import { getEventBus, ServiceWorkerEvent } from './classes.eventbus.js';
 import { getPersistentStore } from './classes.persistentstore.js';
+import { getRequestLogStore } from './classes.requestlogstore.js';

 // Add type definitions for ServiceWorker APIs
 declare global {
@@ -47,6 +48,27 @@ export class ServiceworkerBackend {
  private swSelf: ServiceWorkerGlobalScope;
  private clientUpdateInterval: ReturnType<typeof setInterval> | null = null;

+  // Throttling for metrics updates (max 1 per 500ms)
+  private metricsUpdateThrottle: ReturnType<typeof setTimeout> | null = null;
+  private pendingMetricsUpdate = false;
+  private readonly METRICS_THROTTLE_MS = 500;
+
+  /**
+   * Helper to create properly formatted TypedRequest messages for DeesComms
+   */
+  private createMessage<T>(method: string, request: T): any {
+    const id = `${method}_${Date.now()}`;
+    return {
+      method,
+      request,
+      messageId: id,
+      correlation: {
+        id,
+        phase: 'request' as const
+      }
+    };
+  }
+
  constructor(optionsArg: {
    self: any;
    purgeCache: (reqArg: interfaces.serviceworker.IRequest_PurgeServiceWorkerCache['request']) => Promise<interfaces.serviceworker.IRequest_PurgeServiceWorkerCache['response']>;
@@ -98,6 +120,7 @@ export class ServiceworkerBackend {
        limit: reqArg.limit,
        type: reqArg.type,
        since: reqArg.since,
+        before: reqArg.before,
      });
    });

@@ -121,6 +144,49 @@ export class ServiceworkerBackend {
      return { count };
    });

+    // ================================
+    // TypedRequest Traffic Monitoring
+    // ================================
+
+    // Handler for receiving TypedRequest logs from clients
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IMessage_Serviceworker_TypedRequestLog>('serviceworker_typedRequestLog', async (reqArg) => {
+      const requestLogStore = getRequestLogStore();
+      requestLogStore.addEntry(reqArg);
+
+      // Broadcast to sw-dash viewers
+      await this.broadcastTypedRequestLogged(reqArg);
+      return {};
+    });
+
+    // Handler for getting TypedRequest logs
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_GetTypedRequestLogs>('serviceworker_getTypedRequestLogs', async (reqArg) => {
+      const requestLogStore = getRequestLogStore();
+      const logs = requestLogStore.getEntries({
+        limit: reqArg.limit,
+        method: reqArg.method,
+        since: reqArg.since,
+        before: reqArg.before,
+      });
+      const totalCount = requestLogStore.getTotalCount({
+        method: reqArg.method,
+        since: reqArg.since,
+      });
+      return { logs, totalCount };
+    });
+
+    // Handler for getting TypedRequest statistics
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_GetTypedRequestStats>('serviceworker_getTypedRequestStats', async () => {
+      const requestLogStore = getRequestLogStore();
+      return requestLogStore.getStats();
+    });
+
+    // Handler for clearing TypedRequest logs
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_ClearTypedRequestLogs>('serviceworker_clearTypedRequestLogs', async () => {
+      const requestLogStore = getRequestLogStore();
+      requestLogStore.clear();
+      return { success: true };
+    });
+
    // Periodically update connected clients count
    this.startClientCountUpdates();

@@ -239,17 +305,24 @@ export class ServiceworkerBackend {
   */
  public async broadcastStatusUpdate(status: interfaces.serviceworker.IStatusUpdate): Promise<void> {
    try {
-      await this.deesComms.postMessage({
-        method: 'serviceworker_statusUpdate',
-        request: status,
-        messageId: `sw_status_${Date.now()}`
-      });
+      await this.deesComms.postMessage(this.createMessage('serviceworker_statusUpdate', status));
      logger.log('info', `Status update broadcast: ${status.source}:${status.type} - ${status.message}`);
    } catch (error) {
      logger.log('warn', `Failed to broadcast status update: ${error}`);
    }
  }

+  /**
+   * Broadcasts a TypedRequest log entry to all connected clients (for sw-dash)
+   */
+  public async broadcastTypedRequestLogged(entry: interfaces.serviceworker.ITypedRequestLogEntry): Promise<void> {
+    try {
+      await this.deesComms.postMessage(this.createMessage('serviceworker_typedRequestLogged', entry));
+    } catch (error) {
+      logger.log('warn', `Failed to broadcast TypedRequest log: ${error}`);
+    }
+  }
+
  /**
   * Start periodic updates of connected client count
   */
@@ -285,11 +358,7 @@ export class ServiceworkerBackend {

      // 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()}`
-      });
+      await this.deesComms.postMessage(this.createMessage('serviceworker_newVersion', {}));

      // As a fallback, also use the clients API to reload clients that might not catch the broadcast
      const clients = await this.swSelf.clients.matchAll({ type: 'window' });
@@ -352,17 +421,101 @@ export class ServiceworkerBackend {
      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()}`
-      });
+      await this.deesComms.postMessage(this.createMessage('serviceworker_alert', { message: alertText }));
      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)}`);
    }
  }
+
+  // ===============
+  // Push methods for real-time updates
+  // ===============
+
+  /**
+   * Pushes a new event log entry to all connected clients
+   * Called immediately when an event is logged
+   */
+  public async pushEvent(entry: interfaces.serviceworker.IEventLogEntry): Promise<void> {
+    try {
+      await this.deesComms.postMessage(this.createMessage('serviceworker_eventLogged', entry));
+      logger.log('note', `Pushed event to clients: ${entry.type}`);
+    } catch (error) {
+      logger.log('warn', `Failed to push event: ${error}`);
+    }
+  }
+
+  /**
+   * Pushes a metrics update to all connected clients
+   * Throttled to max 1 update per 500ms to prevent spam
+   */
+  public pushMetricsUpdate(): void {
+    // Mark that we have a pending update
+    this.pendingMetricsUpdate = true;
+
+    // If we're already throttling, just wait for the next window
+    if (this.metricsUpdateThrottle) {
+      return;
+    }
+
+    // Send the update and start throttle window
+    this.sendMetricsUpdate();
+
+    this.metricsUpdateThrottle = setTimeout(() => {
+      this.metricsUpdateThrottle = null;
+      // If there was a pending update during the throttle window, send it now
+      if (this.pendingMetricsUpdate) {
+        this.sendMetricsUpdate();
+      }
+    }, this.METRICS_THROTTLE_MS);
+  }
+
+  /**
+   * Actually sends the metrics update via DeesComms
+   */
+  private async sendMetricsUpdate(): Promise<void> {
+    this.pendingMetricsUpdate = false;
+    const metrics = getMetricsCollector();
+    const metricsData = metrics.getMetrics();
+
+    const snapshot: interfaces.serviceworker.IMetricsSnapshot = {
+      cache: {
+        hits: metricsData.cache.hits,
+        misses: metricsData.cache.misses,
+        errors: metricsData.cache.errors,
+        bytesServedFromCache: metricsData.cache.bytesServedFromCache,
+        bytesFetched: metricsData.cache.bytesFetched,
+      },
+      network: {
+        totalRequests: metricsData.network.totalRequests,
+        successfulRequests: metricsData.network.successfulRequests,
+        failedRequests: metricsData.network.failedRequests,
+      },
+      cacheHitRate: metrics.getCacheHitRate(),
+      networkSuccessRate: metrics.getNetworkSuccessRate(),
+      resourceCount: metrics.getResourceCount(),
+      uptime: metricsData.uptime,
+      timestamp: Date.now(),
+    };
+
+    try {
+      await this.deesComms.postMessage(this.createMessage('serviceworker_metricsUpdate', snapshot));
+    } catch (error) {
+      logger.log('warn', `Failed to push metrics update: ${error}`);
+    }
+  }
+
+  /**
+   * Pushes notification when a resource is cached
+   */
+  public async pushResourceCached(url: string, contentType: string, size: number, cached: boolean): Promise<void> {
+    try {
+      await this.deesComms.postMessage(this.createMessage('serviceworker_resourceCached', { url, contentType, size, cached }));
+    } catch (error) {
+      logger.log('warn', `Failed to push resource cached: ${error}`);
+    }
+  }
 }
--- a/ts_web_serviceworker/classes.cachemanager.ts
+++ b/ts_web_serviceworker/classes.cachemanager.ts
@@ -210,42 +210,27 @@ export class CacheManager {
          fetchEventArg.respondWith(Promise.resolve(dashboard.serveDashboard()));
          return;
        }
+        // /sw-dash/metrics - THE initial seed endpoint (provides ALL data)
        if (parsedUrl.pathname === '/sw-dash/metrics') {
          const dashboard = getDashboardGenerator();
-          fetchEventArg.respondWith(Promise.resolve(dashboard.serveMetrics()));
+          fetchEventArg.respondWith(dashboard.serveMetrics());
          return;
        }
+        // /sw-dash/speedtest - user-triggered speedtest
        if (parsedUrl.pathname === '/sw-dash/speedtest') {
          const dashboard = getDashboardGenerator();
          fetchEventArg.respondWith(dashboard.runSpeedtest());
          return;
        }
+        // /sw-dash/resources - resource data (kept for now, could be merged into metrics)
        if (parsedUrl.pathname === '/sw-dash/resources') {
          const dashboard = getDashboardGenerator();
          fetchEventArg.respondWith(Promise.resolve(dashboard.serveResources()));
          return;
        }
-        if (parsedUrl.pathname === '/sw-dash/events') {
-          const dashboard = getDashboardGenerator();
-          fetchEventArg.respondWith(dashboard.serveEventLog(parsedUrl.searchParams));
-          return;
-        }
-        if (parsedUrl.pathname === '/sw-dash/events/count') {
-          const dashboard = getDashboardGenerator();
-          fetchEventArg.respondWith(dashboard.serveEventCount(parsedUrl.searchParams));
-          return;
-        }
-        if (parsedUrl.pathname === '/sw-dash/cumulative-metrics') {
-          const dashboard = getDashboardGenerator();
-          fetchEventArg.respondWith(Promise.resolve(dashboard.serveCumulativeMetrics()));
-          return;
-        }
-        // DELETE method for clearing events
-        if (parsedUrl.pathname === '/sw-dash/events' && originalRequest.method === 'DELETE') {
-          const dashboard = getDashboardGenerator();
-          fetchEventArg.respondWith(dashboard.clearEventLog());
-          return;
-        }
+        // All other /sw-dash/* routes removed - use DeesComms instead:
+        // - Events: via serviceworker_getEventLog, serviceworker_clearEventLog
+        // - Requests: via serviceworker_getTypedRequestLogs, serviceworker_clearTypedRequestLogs

        // Block requests that we don't want the service worker to handle.
        if (
--- a/ts_web_serviceworker/classes.dashboard.ts
+++ b/ts_web_serviceworker/classes.dashboard.ts
@@ -1,6 +1,7 @@
 import { getMetricsCollector } from './classes.metrics.js';
 import { getServiceWorkerInstance } from './init.js';
 import { getPersistentStore } from './classes.persistentstore.js';
+import { getRequestLogStore } from './classes.requestlogstore.js';
 import * as interfaces from './env.js';
 import type { serviceworker } from '../dist_ts_interfaces/index.js';

@@ -24,15 +25,87 @@ export class DashboardGenerator {
  }

  /**
-   * Serves the metrics JSON endpoint
+   * Serves the metrics JSON endpoint with ALL initial data
+   * This is the single HTTP seed request that provides:
+   * - Current metrics
+   * - Initial events (last 50)
+   * - Initial request logs (last 50)
+   * - Request stats and methods
+   * - Resource data
   */
-  public serveMetrics(): Response {
-    return new Response(this.generateMetricsJson(), {
-      headers: {
-        'Content-Type': 'application/json',
-        'Cache-Control': 'no-store',
-      },
-    });
+  public async serveMetrics(): Promise<Response> {
+    try {
+      const metrics = getMetricsCollector();
+      const persistentStore = getPersistentStore();
+      await persistentStore.init();
+      const requestLogStore = getRequestLogStore();
+
+      // Get event data
+      const eventResult = await persistentStore.getEventLog({ limit: 50 });
+      const oneHourAgo = Date.now() - 3600000;
+      const eventCountLastHour = await persistentStore.getEventCount(oneHourAgo);
+
+      // Build comprehensive initial response
+      const data = {
+        // Core metrics
+        ...metrics.getMetrics(),
+        cacheHitRate: metrics.getCacheHitRate(),
+        networkSuccessRate: metrics.getNetworkSuccessRate(),
+        resourceCount: metrics.getResourceCount(),
+        summary: metrics.getSummary(),
+
+        // Resources data
+        resources: metrics.getCachedResources(),
+        domains: metrics.getDomainStats(),
+        contentTypes: metrics.getContentTypeStats(),
+
+        // Events data (initial 50)
+        events: eventResult.events,
+        eventTotalCount: eventResult.totalCount,
+        eventCountLastHour,
+
+        // Request logs data (initial 50)
+        requestLogs: requestLogStore.getEntries({ limit: 50 }),
+        requestTotalCount: requestLogStore.getTotalCount(),
+        requestStats: requestLogStore.getStats(),
+        requestMethods: requestLogStore.getMethods(),
+      };
+
+      return new Response(JSON.stringify(data), {
+        headers: {
+          'Content-Type': 'application/json',
+          'Cache-Control': 'no-store',
+        },
+      });
+    } catch (error) {
+      console.error('[SW Dashboard] serveMetrics error:', error);
+      // Return error response with valid JSON structure so client doesn't crash
+      return new Response(JSON.stringify({
+        error: String(error),
+        cache: { hits: 0, misses: 0, errors: 0, bytesServedFromCache: 0, bytesFetched: 0, averageResponseTime: 0 },
+        network: { totalRequests: 0, successfulRequests: 0, failedRequests: 0, timeouts: 0, averageLatency: 0, totalBytesTransferred: 0 },
+        update: { totalChecks: 0, successfulChecks: 0, failedChecks: 0, updatesFound: 0, updatesApplied: 0, lastCheckTimestamp: 0, lastUpdateTimestamp: 0 },
+        connection: { connectedClients: 0, totalConnectionAttempts: 0, successfulConnections: 0, failedConnections: 0 },
+        speedtest: { lastDownloadSpeedMbps: 0, lastUploadSpeedMbps: 0, lastLatencyMs: 0, lastTestTimestamp: 0, testCount: 0, isOnline: false },
+        startTime: Date.now(),
+        uptime: 0,
+        cacheHitRate: 0,
+        networkSuccessRate: 0,
+        resourceCount: 0,
+        events: [],
+        eventTotalCount: 0,
+        eventCountLastHour: 0,
+        requestLogs: [],
+        requestTotalCount: 0,
+        requestStats: { totalRequests: 0, totalResponses: 0, methodCounts: {}, errorCount: 0, avgDurationMs: 0 },
+        requestMethods: [],
+      }), {
+        headers: {
+          'Content-Type': 'application/json',
+          'Cache-Control': 'no-store',
+        },
+      });
+    }
  }

  /**
@@ -52,6 +125,7 @@ export class DashboardGenerator {
   */
  public async serveEventLog(searchParams: URLSearchParams): Promise<Response> {
    const persistentStore = getPersistentStore();
+    await persistentStore.init();

    const limit = searchParams.get('limit') ? parseInt(searchParams.get('limit')!, 10) : undefined;
    const type = searchParams.get('type') as TEventType | undefined;
@@ -72,6 +146,7 @@ export class DashboardGenerator {
   */
  public async serveEventCount(searchParams: URLSearchParams): Promise<Response> {
    const persistentStore = getPersistentStore();
+    await persistentStore.init();

    const since = searchParams.get('since') ? parseInt(searchParams.get('since')!, 10) : Date.now() - 3600000; // Default: last hour

@@ -88,8 +163,9 @@ export class DashboardGenerator {
  /**
   * Serves cumulative metrics
   */
-  public serveCumulativeMetrics(): Response {
+  public async serveCumulativeMetrics(): Promise<Response> {
    const persistentStore = getPersistentStore();
+    await persistentStore.init();
    const metrics = persistentStore.getCumulativeMetrics();

    return new Response(JSON.stringify(metrics), {
@@ -105,6 +181,7 @@ export class DashboardGenerator {
   */
  public async clearEventLog(): Promise<Response> {
    const persistentStore = getPersistentStore();
+    await persistentStore.init();
    const success = await persistentStore.clearEventLog();

    return new Response(JSON.stringify({ success }), {
@@ -115,6 +192,76 @@ export class DashboardGenerator {
    });
  }

+  // ================================
+  // TypedRequest Traffic Endpoints
+  // ================================
+
+  /**
+   * Serves TypedRequest traffic logs
+   */
+  public serveTypedRequestLogs(searchParams: URLSearchParams): Response {
+    const requestLogStore = getRequestLogStore();
+
+    const limit = searchParams.get('limit') ? parseInt(searchParams.get('limit')!, 10) : undefined;
+    const method = searchParams.get('method') || undefined;
+    const since = searchParams.get('since') ? parseInt(searchParams.get('since')!, 10) : undefined;
+
+    const logs = requestLogStore.getEntries({ limit, method, since });
+    const totalCount = requestLogStore.getTotalCount({ method, since });
+
+    return new Response(JSON.stringify({ logs, totalCount }), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Serves TypedRequest traffic statistics
+   */
+  public serveTypedRequestStats(): Response {
+    const requestLogStore = getRequestLogStore();
+    const stats = requestLogStore.getStats();
+
+    return new Response(JSON.stringify(stats), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Clears TypedRequest traffic logs
+   */
+  public clearTypedRequestLogs(): Response {
+    const requestLogStore = getRequestLogStore();
+    requestLogStore.clear();
+
+    return new Response(JSON.stringify({ success: true }), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Serves unique method names from TypedRequest logs
+   */
+  public serveTypedRequestMethods(): Response {
+    const requestLogStore = getRequestLogStore();
+    const methods = requestLogStore.getMethods();
+
+    return new Response(JSON.stringify({ methods }), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
  // Speedtest configuration
  private static readonly TEST_DURATION_MS = 5000;  // 5 seconds per test
  private static readonly CHUNK_SIZE_KB = 64;       // 64KB chunks
@@ -126,6 +273,7 @@ export class DashboardGenerator {
  public async runSpeedtest(): Promise<Response> {
    const metrics = getMetricsCollector();
    const persistentStore = getPersistentStore();
+    await persistentStore.init();
    const results: {
      latency?: { durationMs: number };
      download?: { durationMs: number; speedMbps: number; bytesTransferred: number };
@@ -257,25 +405,7 @@ export class DashboardGenerator {
   * Generates a minimal HTML shell that loads the Lit-based dashboard bundle
   */
  public generateDashboardHtml(): string {
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>SW Dashboard</title>
-  <style>
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    body {
-      background: #0a0a0a;
-      min-height: 100vh;
-    }
-  </style>
-</head>
-<body>
-  <sw-dash-app></sw-dash-app>
-  <script type="module" src="/sw-dash/bundle.js"></script>
-</body>
-</html>`;
+    return interfaces.serviceworker.SW_DASH_HTML;
  }

 }
--- a/ts_web_serviceworker/classes.metrics.ts
+++ b/ts_web_serviceworker/classes.metrics.ts
@@ -1,4 +1,5 @@
 import { logger } from './logging.js';
+import { getServiceWorkerBackend } from './init.js';

 /**
 * Interface for cache metrics
@@ -178,6 +179,20 @@ export class MetricsCollector {
    this.startTime = Date.now();
  }

+  /**
+   * Triggers a push metrics update to all connected clients (throttled in backend)
+   */
+  private triggerPushUpdate(): void {
+    try {
+      const backend = getServiceWorkerBackend();
+      if (backend) {
+        backend.pushMetricsUpdate();
+      }
+    } catch (error) {
+      // Silently ignore - push is best-effort
+    }
+  }
+
  /**
   * Gets the singleton instance
   */
@@ -196,11 +211,13 @@ export class MetricsCollector {
    this.cacheHits++;
    this.bytesServedFromCache += bytes;
    logger.log('note', `[Metrics] Cache hit: ${url} (${bytes} bytes)`);
+    this.triggerPushUpdate();
  }

  public recordCacheMiss(url: string): void {
    this.cacheMisses++;
    logger.log('note', `[Metrics] Cache miss: ${url}`);
+    this.triggerPushUpdate();
  }

  public recordCacheError(url: string, error?: string): void {
@@ -224,11 +241,13 @@ export class MetricsCollector {
    this.successfulRequests++;
    this.totalBytesTransferred += bytes;
    this.recordResponseTime(url, duration);
+    this.triggerPushUpdate();
  }

  public recordRequestFailure(url: string, error?: string): void {
    this.failedRequests++;
    logger.log('warn', `[Metrics] Request failed: ${url} - ${error || 'unknown'}`);
+    this.triggerPushUpdate();
  }

  public recordTimeout(url: string, duration: number): void {
--- a/ts_web_serviceworker/classes.persistentstore.ts
+++ b/ts_web_serviceworker/classes.persistentstore.ts
@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
 import { logger } from './logging.js';
 import type { serviceworker } from '../dist_ts_interfaces/index.js';
+import { getServiceWorkerBackend } from './init.js';

 type ICumulativeMetrics = serviceworker.ICumulativeMetrics;
 type IEventLogEntry = serviceworker.IEventLogEntry;
@@ -66,7 +67,7 @@ export class PersistentStore {

  private constructor() {
    this.store = new plugins.webstore.WebStore({
-      dbName: 'losslessServiceworker',
+      dbName: 'losslessServiceworkerPersistent',
      storeName: 'persistentStore',
    });
  }
@@ -90,6 +91,7 @@ export class PersistentStore {
    }

    try {
+      // Initialize the WebStore (required before using any methods)
      await this.store.init();
      await this.loadCumulativeMetrics();

@@ -107,7 +109,8 @@ export class PersistentStore {
      logger.log('ok', '[PersistentStore] Initialized successfully');
    } catch (error) {
      logger.log('error', `[PersistentStore] Failed to initialize: ${error}`);
-      throw error;
+      // Don't throw - allow SW to continue even if persistent store fails
+      this.initialized = true; // Mark as initialized to prevent retry loops
    }
  }

@@ -271,6 +274,11 @@ export class PersistentStore {
    };

    try {
+      // Ensure initialized
+      if (!this.initialized) {
+        await this.init();
+      }
+
      let events: IEventLogEntry[] = [];

      if (await this.store.check(this.EVENT_LOG_KEY)) {
@@ -285,6 +293,17 @@ export class PersistentStore {

      await this.store.set(this.EVENT_LOG_KEY, events);
      logger.log('note', `[PersistentStore] Logged event: ${type} - ${message}`);
+
+      // Push event to connected clients via DeesComms
+      try {
+        const backend = getServiceWorkerBackend();
+        if (backend) {
+          await backend.pushEvent(entry);
+        }
+      } catch (pushError) {
+        // Don't fail the log operation if push fails
+        logger.log('warn', `[PersistentStore] Failed to push event: ${pushError}`);
+      }
    } catch (error) {
      logger.log('error', `[PersistentStore] Failed to log event: ${error}`);
    }
@@ -297,6 +316,7 @@ export class PersistentStore {
    limit?: number;
    type?: TEventType;
    since?: number;
+    before?: number;
  }): Promise<{ events: IEventLogEntry[]; totalCount: number }> {
    try {
      let events: IEventLogEntry[] = [];
@@ -317,6 +337,11 @@ export class PersistentStore {
        events = events.filter(e => e.timestamp >= options.since);
      }

+      // Filter by before timestamp (for pagination)
+      if (options?.before) {
+        events = events.filter(e => e.timestamp < options.before);
+      }
+
      // Sort by timestamp (newest first)
      events.sort((a, b) => b.timestamp - a.timestamp);

--- a/ts_web_serviceworker/classes.requestlogstore.ts
+++ b/ts_web_serviceworker/classes.requestlogstore.ts
@@ -0,0 +1,196 @@
+import { logger } from './logging.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+
+/**
+ * Store for TypedRequest traffic logs
+ * Keeps recent request/response logs in memory for dashboard display
+ */
+export class RequestLogStore {
+  private logs: interfaces.serviceworker.ITypedRequestLogEntry[] = [];
+  private maxEntries: number;
+
+  // Statistics
+  private stats: interfaces.serviceworker.ITypedRequestStats = {
+    totalRequests: 0,
+    totalResponses: 0,
+    methodCounts: {},
+    errorCount: 0,
+    avgDurationMs: 0,
+  };
+
+  // For calculating rolling average
+  private totalDuration = 0;
+  private durationCount = 0;
+
+  constructor(maxEntries = 500) {
+    this.maxEntries = maxEntries;
+    logger.log('info', `RequestLogStore initialized with max ${maxEntries} entries`);
+  }
+
+  /**
+   * Add a new log entry
+   */
+  public addEntry(entry: interfaces.serviceworker.ITypedRequestLogEntry): void {
+    // Add to log
+    this.logs.push(entry);
+
+    // Trim if over max
+    if (this.logs.length > this.maxEntries) {
+      this.logs.shift();
+    }
+
+    // Update statistics
+    this.updateStats(entry);
+  }
+
+  /**
+   * Update statistics based on new entry
+   */
+  private updateStats(entry: interfaces.serviceworker.ITypedRequestLogEntry): void {
+    // Count request/response
+    if (entry.phase === 'request') {
+      this.stats.totalRequests++;
+    } else {
+      this.stats.totalResponses++;
+    }
+
+    // Count errors
+    if (entry.error) {
+      this.stats.errorCount++;
+    }
+
+    // Update duration average
+    if (entry.durationMs !== undefined) {
+      this.totalDuration += entry.durationMs;
+      this.durationCount++;
+      this.stats.avgDurationMs = Math.round(this.totalDuration / this.durationCount);
+    }
+
+    // Update per-method counts
+    if (!this.stats.methodCounts[entry.method]) {
+      this.stats.methodCounts[entry.method] = {
+        requests: 0,
+        responses: 0,
+        errors: 0,
+        avgDurationMs: 0,
+      };
+    }
+
+    const methodStats = this.stats.methodCounts[entry.method];
+    if (entry.phase === 'request') {
+      methodStats.requests++;
+    } else {
+      methodStats.responses++;
+    }
+
+    if (entry.error) {
+      methodStats.errors++;
+    }
+
+    // Per-method duration tracking (simplified - just uses latest duration)
+    if (entry.durationMs !== undefined) {
+      // Rolling average for method
+      const currentAvg = methodStats.avgDurationMs || 0;
+      const count = methodStats.responses || 1;
+      methodStats.avgDurationMs = Math.round((currentAvg * (count - 1) + entry.durationMs) / count);
+    }
+  }
+
+  /**
+   * Get log entries with optional filters
+   */
+  public getEntries(options?: {
+    limit?: number;
+    method?: string;
+    since?: number;
+    before?: number;
+  }): interfaces.serviceworker.ITypedRequestLogEntry[] {
+    let result = [...this.logs];
+
+    // Filter by method
+    if (options?.method) {
+      result = result.filter((e) => e.method === options.method);
+    }
+
+    // Filter by timestamp (since)
+    if (options?.since) {
+      result = result.filter((e) => e.timestamp >= options.since);
+    }
+
+    // Filter by timestamp (before - for pagination)
+    if (options?.before) {
+      result = result.filter((e) => e.timestamp < options.before);
+    }
+
+    // Sort by timestamp descending (newest first)
+    result.sort((a, b) => b.timestamp - a.timestamp);
+
+    // Apply limit
+    if (options?.limit && options.limit > 0) {
+      result = result.slice(0, options.limit);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get total count of entries (for pagination)
+   */
+  public getTotalCount(options?: { method?: string; since?: number }): number {
+    if (!options?.method && !options?.since) {
+      return this.logs.length;
+    }
+
+    let count = 0;
+    for (const entry of this.logs) {
+      if (options.method && entry.method !== options.method) continue;
+      if (options.since && entry.timestamp < options.since) continue;
+      count++;
+    }
+    return count;
+  }
+
+  /**
+   * Get statistics
+   */
+  public getStats(): interfaces.serviceworker.ITypedRequestStats {
+    return { ...this.stats };
+  }
+
+  /**
+   * Clear all logs and reset stats
+   */
+  public clear(): void {
+    this.logs = [];
+    this.stats = {
+      totalRequests: 0,
+      totalResponses: 0,
+      methodCounts: {},
+      errorCount: 0,
+      avgDurationMs: 0,
+    };
+    this.totalDuration = 0;
+    this.durationCount = 0;
+    logger.log('info', 'RequestLogStore cleared');
+  }
+
+  /**
+   * Get unique method names
+   */
+  public getMethods(): string[] {
+    return Object.keys(this.stats.methodCounts);
+  }
+}
+
+// Singleton instance
+let requestLogStoreInstance: RequestLogStore | null = null;
+
+/**
+ * Get the singleton RequestLogStore instance
+ */
+export function getRequestLogStore(): RequestLogStore {
+  if (!requestLogStoreInstance) {
+    requestLogStoreInstance = new RequestLogStore();
+  }
+  return requestLogStoreInstance;
+}
--- a/ts_web_serviceworker/classes.serviceworker.ts
+++ b/ts_web_serviceworker/classes.serviceworker.ts
@@ -95,6 +95,7 @@ export class ServiceWorker {

        // Log activation event
        const persistentStore = getPersistentStore();
+        await persistentStore.init();  // Ensure store is initialized (safe to call multiple times)
        await persistentStore.logEvent('sw_activated', 'Service worker activated', {
          timestamp: new Date().toISOString(),
        });
@@ -109,6 +110,13 @@ export class ServiceWorker {
        done.reject(error);
      }
    });
+
+    // Handle wake-up scenario: if already activated, connect immediately
+    // (install/activate events don't fire on wake-up)
+    if (selfArg.registration?.active) {
+      logger.log('info', 'SW woke up (already activated) - connecting to server');
+      this.connectToServer();
+    }
  }

  /**
@@ -123,6 +131,7 @@ export class ServiceWorker {

          // Log cache invalidation event (survives)
          const persistentStore = getPersistentStore();
+          await persistentStore.init();  // Ensure store is initialized
          await persistentStore.logEvent('cache_invalidated', `Cache invalidated: ${reqArg.reason}`, {
            reason: reqArg.reason,
            timestamp: reqArg.timestamp,
--- a/ts_web_serviceworker/env.ts
+++ b/ts_web_serviceworker/env.ts
@@ -16,5 +16,6 @@ export interface ServiceWindow extends Window {
  location: any;
  skipWaiting: any;
  clients: any;
+  registration?: ServiceWorkerRegistration;
 }
 declare var self: Window;
--- a/ts_web_serviceworker/init.ts
+++ b/ts_web_serviceworker/init.ts
@@ -4,7 +4,10 @@ import * as env from './env.js';
 declare var self: env.ServiceWindow;

 import { ServiceWorker } from './classes.serviceworker.js';
+import type { ServiceworkerBackend } from './classes.backend.js';

 const sw = new ServiceWorker(self);

 export const getServiceWorkerInstance = (): ServiceWorker => sw;
+
+export const getServiceWorkerBackend = (): ServiceworkerBackend => sw.leleServiceWorkerBackend;
--- a/ts_web_serviceworker_client/classes.actionmanager.ts
+++ b/ts_web_serviceworker_client/classes.actionmanager.ts
@@ -191,4 +191,88 @@ export class ActionManager {
    const response = await tr.fire({});
    return response;
  }
+
+  // ================================
+  // TypedRequest Traffic Logging
+  // ================================
+
+  /**
+   * Log a TypedRequest entry to the service worker for dashboard display
+   */
+  public async logTypedRequest(entry: interfaces.serviceworker.ITypedRequestLogEntry): Promise<void> {
+    try {
+      const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IMessage_Serviceworker_TypedRequestLog>('serviceworker_typedRequestLog');
+      await tr.fire(entry);
+    } catch (error) {
+      // Silently ignore logging errors to avoid infinite loops
+      // (logging the error would trigger another log entry)
+    }
+  }
+
+  /**
+   * Get TypedRequest traffic logs from the service worker
+   */
+  public async getTypedRequestLogs(options?: {
+    limit?: number;
+    method?: string;
+    since?: number;
+  }): Promise<interfaces.serviceworker.IRequest_Serviceworker_GetTypedRequestLogs['response'] | null> {
+    try {
+      const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Serviceworker_GetTypedRequestLogs>('serviceworker_getTypedRequestLogs');
+      return await tr.fire(options || {});
+    } catch (error) {
+      logger.log('warn', `Failed to get TypedRequest logs: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Get TypedRequest traffic statistics from the service worker
+   */
+  public async getTypedRequestStats(): Promise<interfaces.serviceworker.ITypedRequestStats | null> {
+    try {
+      const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Serviceworker_GetTypedRequestStats>('serviceworker_getTypedRequestStats');
+      return await tr.fire({});
+    } catch (error) {
+      logger.log('warn', `Failed to get TypedRequest stats: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Clear TypedRequest traffic logs
+   */
+  public async clearTypedRequestLogs(): Promise<boolean> {
+    try {
+      const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Serviceworker_ClearTypedRequestLogs>('serviceworker_clearTypedRequestLogs');
+      const result = await tr.fire({});
+      return result.success;
+    } catch (error) {
+      logger.log('warn', `Failed to clear TypedRequest logs: ${error}`);
+      return false;
+    }
+  }
+
+  /**
+   * Subscribe to real-time TypedRequest log entries
+   * @returns Unsubscribe function
+   */
+  public subscribeToTypedRequestLogs(callback: (entry: interfaces.serviceworker.ITypedRequestLogEntry) => void): () => void {
+    // Create handler for broadcast messages
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IMessage_Serviceworker_TypedRequestLogged>('serviceworker_typedRequestLogged', async (entry) => {
+      try {
+        callback(entry);
+      } catch (error) {
+        logger.log('warn', `TypedRequest log callback error: ${error}`);
+      }
+      return {};
+    });
+
+    logger.log('info', 'Subscribed to TypedRequest log updates');
+
+    // Return unsubscribe function (note: DeesComms doesn't support removing handlers)
+    return () => {
+      logger.log('info', 'Unsubscribed from TypedRequest log updates (handler remains active)');
+    };
+  }
 }
Author	SHA1	Message	Date
Juergen Kunz	e1310269fe	7.8.3 Some checks failed Default (tags) / security (push) Failing after 53s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-12-04 20:56:34 +00:00
Juergen Kunz	1aadc2da21	feat(serviceworker): Add endpoint to serve serviceworker bundle with error handling	2025-12-04 20:56:16 +00:00
Juergen Kunz	37426f0708	7.8.2 Some checks failed Default (tags) / security (push) Failing after 55s Details Default (tags) / test (push) Failing after 14s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-12-04 20:17:18 +00:00
Juergen Kunz	c124a06bc6	feat(dashboard): Add error handling to serveMetrics method for improved resilience	2025-12-04 20:17:10 +00:00
Juergen Kunz	849e7f4407	7.8.1 Some checks failed Default (tags) / security (push) Failing after 34s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-12-04 20:07:42 +00:00
Juergen Kunz	3baf171394	feat(serviceworker): Enhance event and request logging with pagination support	2025-12-04 20:07:40 +00:00
Juergen Kunz	065987c854	v7.8.0 Some checks failed Default (tags) / security (push) Failing after 17s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-12-04 19:25:55 +00:00
Juergen Kunz	c5c40e78f9	feat(serviceworker): Add TypedRequest traffic monitoring and SW dashboard Requests panel	2025-12-04 19:25:55 +00:00
Juergen Kunz	d3330880c0	v7.7.1 Some checks failed Default (tags) / security (push) Failing after 16s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-12-04 18:07:52 +00:00
Juergen Kunz	dbbfd313ae	fix(web_serviceworker): Standardize DeesComms message format in service worker backend	2025-12-04 18:07:52 +00:00
Juergen Kunz	eabee2d658	v7.7.0 Some checks failed Default (tags) / security (push) Failing after 16s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-12-04 17:26:34 +00:00
Juergen Kunz	95cd681380	feat(typedserver): Add SPA fallback support to TypedServer	2025-12-04 17:26:34 +00:00
Juergen Kunz	9f6290f7aa	v7.6.0 Some checks failed Default (tags) / security (push) Failing after 19s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-12-04 17:12:52 +00:00
Juergen Kunz	065a253b3e	feat(typedserver): Remove legacy Express-based servertools, drop express deps, and refactor TypedServer to SmartServe + typedrouter with CORS support	2025-12-04 17:12:52 +00:00
Juergen Kunz	722bf5d946	v7.5.0 Some checks failed Default (tags) / security (push) Failing after 16s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-12-04 16:25:51 +00:00
Juergen Kunz	299e3ac33f	feat(serviceworker): Add real-time service worker push updates and DeesComms integration (metrics, events, resource caching)	2025-12-04 16:25:51 +00:00
Juergen Kunz	951a48cf88	v7.4.1 Some checks failed Default (tags) / security (push) Failing after 16s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-12-04 15:33:47 +00:00
Juergen Kunz	8b7fe245f0	fix(web_serviceworker): Improve service worker persistence, metrics and caching robustness	2025-12-04 15:33:47 +00:00