7.8.4

.serena/.gitignore

@@ -1 +0,0 @@
-/cache

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

changelog.md

@@ -1,5 +1,151 @@
 # 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
+
+- Add PersistentStore (ts_web_serviceworker/classes.persistentstore.ts) to persist event log and cumulative metrics with retention policy and periodic saving.
+- Introduce persistent event types and interfaces for event log and cumulative metrics (ts_interfaces/serviceworker.ts).
+- Log lifecycle, update, network and speedtest events to the persistent store (install, activate, update available/applied/error, network online/offline, speedtest started/completed/failed, cache invalidation).
+- Expose persistent-store APIs via typed handlers in the service worker backend: serviceworker_getEventLog, serviceworker_getCumulativeMetrics, serviceworker_clearEventLog, serviceworker_getEventCount.
+- Serve new dashboard endpoints from the service worker: /sw-dash/events (GET), /sw-dash/events/count (GET), /sw-dash/cumulative-metrics (GET) and DELETE /sw-dash/events to clear the log (handled in classes.cachemanager and classes.dashboard).
+- Add sw-dash events panel component (ts_swdash/sw-dash-events.ts) and integrate an Events tab into the dashboard UI (ts_swdash/sw-dash-app.ts, sw-dash-overview.ts shows 1h event count).
+- Reset cumulative metrics on cache invalidation and increment swRestartCount on PersistentStore.init().
+- Record speedtest lifecycle events (started/completed/failed) and include details in the event log.
+
+## 2025-12-04 - 7.3.0 - feat(serviceworker)
+Modernize SW dashboard UI and improve service worker backend and server tooling
+
+- Revamped sw-dash UI: new header/logo, uptime badge, live auto-refresh indicator, reorganized panels and improved speedtest UI and controls
+- Shared styles overhaul: new theming variables, spacing scale, badges, refined progress/pulse animations and cleaner typography
+- Dashboard internals: metrics endpoint and SPA shell updated; Lit bundle loading and table sort icon changed to ↑/↓
+- Service worker: added request deduplication (in-flight request coalescing), safer caching logic, consistent CORS/caching headers, and cache revalidation
+- Metrics: richer MetricsCollector with per-resource tracking, domain/content-type stats, speedtest metrics and better summary/stat helpers
+- Update & network managers: rate-limited update checks, debounced update/revalidation tasks, online/offline checks and improved retry/backoff logic
+- TypedServer & tooling: addRoute API for custom routes, improved HTML reload script injection, TypedSocket integration and a backend speedtest handler
+- servertools: improved static/proxy handlers (more robust path extraction, compression handling) and deprecation notice for addTypedSocket()
+
+## 2025-12-04 - 7.2.0 - feat(serviceworker)
+Add service worker status updates, EventBus and UI status pill for realtime observability
+
+- Introduce a status update protocol for service worker <-> clients (IStatusUpdate, IMessage_Serviceworker_StatusUpdate, IRequest_Serviceworker_GetStatus).
+- Add typedserver-statuspill Lit component to display backend/serviceworker/network status in the UI, with expand/collapse details and persistent/error states.
+- Wire ReloadChecker to use the new status pill: show network/backend/serviceworker status, handle online/offline events, and subscribe to service worker status broadcasts.
+- Extend ActionManager (client) with subscribeToStatusUpdates and getServiceWorkerStatus helpers; forward serviceworker_statusUpdate broadcasts to registered callbacks.
+- Serviceworker backend: add serviceworker_getStatus handler and broadcastStatusUpdate API; subscribe to EventBus lifecycle/network/update events to broadcast status changes to clients.
+- Add EventBus for decoupled service worker internal events (ServiceWorkerEvent enum, pub/sub API, history and convenience emitters).
+- Ensure proper subscribe/unsubscribe lifecycle (ReloadChecker stops SW subscription on stop).
+- Improve cache/connection status reporting integration so status updates include details like cacheHitRate, resourceCount and connected clients.
+
+## 2025-12-04 - 7.1.0 - feat(swdash)
+Add live speedtest progress UI to service worker dashboard
+
+- Introduce reactive speedtest state (phase, progress, elapsed) in sw-dash-overview component
+- Start a progress interval to animate overall test progress and estimate phases (latency, download, upload)
+- Dispatch 'speedtest-complete' event and show a brief complete state before resetting UI
+- Add helper methods for phase labels and elapsed time formatting
+- Add CSS for progress bar, shimmer animation and phase pulse to sw-dash-styles
+
+## 2025-12-04 - 7.0.0 - BREAKING CHANGE(serviceworker)
+Move serviceworker speedtest to time-based chunked transfers and update dashboard/server contract
+
+- Change speedtest protocol to time-based chunk transfers: new request types 'download_chunk' and 'upload_chunk' plus 'latency'. Clients should call chunk requests in a loop for the desired test duration.
+- IRequest_Serviceworker_Speedtest interface updated: request fields renamed/changed (chunkSizeKB, payload) and response no longer includes durationMs or speedMbps — server now returns bytesTransferred, timestamp, and optional payload.
+- TypedServer speedtest handler updated to support 'download_chunk' and 'upload_chunk' semantics and to return bytesTransferred/timestamp/payload only (removed server-side duration/speed calculation).
+- Dashboard runSpeedtest now performs time-based tests (TEST_DURATION_MS = 5000, CHUNK_SIZE_KB = 64) by repeatedly requesting chunks and computing throughput on the client side.
+- Documentation/comments updated to clarify new speedtest behavior and default chunk sizes.
+
+## 2025-12-04 - 6.8.1 - fix(web_serviceworker)
+Move service worker initialization to init.ts and remove exports from service worker entrypoint to avoid ESM bundle output
+
+- Remove exports from ts_web_serviceworker/index.ts so the service worker entrypoint does not export symbols (prevents tsbundle from producing ESM output).
+- Add ts_web_serviceworker/init.ts which initializes the ServiceWorker instance and exports getServiceWorkerInstance() for internal imports.
+- Update ts_web_serviceworker/classes.dashboard.ts to import getServiceWorkerInstance from init.ts instead of index.ts.
+
+## 2025-12-04 - 6.8.0 - feat(swdash)
+Add SW-Dash (Lit-based service worker dashboard), bundle & serve it; improve servertools and static handlers
+
+- Add a new sw-dash frontend (ts_swdash) implemented with Lit: sw-dash-app, sw-dash-overview, sw-dash-urls, sw-dash-domains, sw-dash-types, sw-dash-table, shared styles and plugin shims.
+- Wire sw-dash into build pipeline and packaging: add ts_swdash bundle to npm build script and include ts_swdash in package files.
+- Serve the dashboard bundle: add paths (swdashBundleDir / swdashBundlePath) and a built-in route (/sw-dash/bundle.js) in BuiltInRoutesController.
+- Simplify service-worker dashboard HTML output to a minimal shell that mounts <sw-dash-app> and loads the module /sw-dash/bundle.js (reduces inline HTML/CSS/JS duplication).
+- Lazy-load service worker bundle and source map in servertools.tools.serviceworker and expose /sw-typedrequest endpoints for SW typed requests (including speedtest handler).
+- Enhance compression utilities and static serving: Compressor now caches compressed results, prioritizes preferred compression methods, provides safer zlib calls, and exposes createCompressionStream; HandlerStatic gained improved path resolution, Express 5 wildcard handling and optional compression flow.
+- Improve proxy/static handler path handling to be compatible with Express 5 wildcard parameters and more robust fallback logic.
+- Deprecate Server.addTypedSocket (no-op) and document recommended SmartServe/TypedServer integration for WebSocket support.
+- Various minor packaging/path updates (paths.ts, plugins exports) to support the new dashboard and bundles.
+
+## 2025-12-04 - 6.7.0 - feat(web_serviceworker)
+Add per-resource metrics and request deduplication to service worker cache manager
+
+- Introduce per-resource tracking in metrics: ICachedResource, IDomainStats, IContentTypeStats and a resourceStats map.
+- Add MetricsCollector.recordResourceAccess(...) to record hits/misses, content-type and size; provide getters: getCachedResources, getDomainStats, getContentTypeStats and getResourceCount.
+- Reset resourceStats when metrics are reset and limit resource entries via cleanupResourceStats to avoid memory bloat.
+- Add request deduplication in CacheManager (fetchWithDeduplication) to coalesce identical concurrent fetches and a periodic safety cleanup for in-flight requests.
+- Record resource accesses on cache hit and when storing new cache entries (captures content-type and body size).
+- Expose a dashboard resources endpoint (/sw-dash/resources) served by the SW dashboard to return detailed resource data for SPA views.
+
 ## 2025-12-04 - 6.6.0 - feat(web_serviceworker)
 Enable service worker dashboard speedtests via TypedSocket, expose ServiceWorker instance to dashboard, and add server-side speedtest handler
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@api.global/typedserver",
-  "version": "6.6.0",
+  "version": "7.8.4",
   "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
   "type": "module",
   "exports": {
@@ -15,7 +15,7 @@
   "scripts": {
     "test": "npm run build && tstest test/ --verbose --logfile --timeout 60",
     "build": "tsbuild tsfolders --web --allowimplicitany && npm run bundle",
-    "bundle": "tsbundle --from ./ts_web_inject/index.ts --to ./dist_ts_web_inject/bundle.js && tsbundle --from ./ts_web_serviceworker/index.ts --to ./dist_ts_web_serviceworker/serviceworker.bundle.js",
+    "bundle": "tsbundle --from ./ts_web_inject/index.ts --to ./dist_ts_web_inject/bundle.js && tsbundle --from ./ts_web_serviceworker/index.ts --to ./dist_ts_web_serviceworker/serviceworker.bundle.js && tsbundle --from ./ts_swdash/index.ts --to ./dist_ts_swdash/bundle.js",
     "interfaces": "tsbuild interfaces --web --allowimplicitany --skiplibcheck",
     "docs": "tsdoc aidoc"
   },
@@ -32,7 +32,6 @@
     "HTTP server",
     "SSL",
     "cors",
-    "express middleware",
     "proxy",
     "sitemap",
     "feeds",
@@ -47,6 +46,7 @@
   "files": [
     "ts/**/*",
     "ts_web/**/*",
+    "ts_swdash/**/*",
     "dist/**/*",
     "dist_*/**/*",
     "dist_ts/**/*",
@@ -91,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": {

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

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@api.global/typedserver',
-  version: '6.6.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.'
 }

ts/classes.typedserver.ts

@@ -3,6 +3,7 @@ import * as paths from './paths.js';
 import * as interfaces from '../dist_ts_interfaces/index.js';
 import { DevToolsController } from './controllers/controller.devtools.js';
 import { TypedRequestController } from './controllers/controller.typedrequest.js';
+import { SwTypedRequestController } from './controllers/controller.swtypedrequest.js';
 import { BuiltInRoutesController } from './controllers/controller.builtin.js';
 
 export interface IServerOptions {
@@ -56,6 +57,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';
@@ -89,6 +96,7 @@ export class TypedServer {
   // Decorated controllers
   private devToolsController: DevToolsController;
   private typedRequestController: TypedRequestController;
+  private swTypedRequestController: SwTypedRequestController;
   private builtInRoutesController: BuiltInRoutesController;
 
   // File server for static files
@@ -214,6 +222,7 @@ export class TypedServer {
     }
 
     this.typedRequestController = new TypedRequestController(this.typedrouter);
+    this.swTypedRequestController = new SwTypedRequestController(this.typedrouter);
 
     this.builtInRoutesController = new BuiltInRoutesController({
       domain: this.options.domain,
@@ -233,6 +242,7 @@ export class TypedServer {
       plugins.smartserve.ControllerRegistry.registerInstance(this.devToolsController);
     }
     plugins.smartserve.ControllerRegistry.registerInstance(this.typedRequestController);
+    plugins.smartserve.ControllerRegistry.registerInstance(this.swTypedRequestController);
     plugins.smartserve.ControllerRegistry.registerInstance(this.builtInRoutesController);
 
     // Compile routes for fast matching
@@ -308,31 +318,31 @@ export class TypedServer {
       );
 
       // Speedtest handler for service worker dashboard
+      // Client calls this in a loop for the test duration to get accurate time-based measurements
       this.typedrouter.addTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Speedtest>(
         new plugins.typedrequest.TypedHandler('serviceworker_speedtest', async (reqArg) => {
-          const startTime = Date.now();
-          const payloadSizeKB = reqArg.payloadSizeKB || 100;
-          const sizeBytes = payloadSizeKB * 1024;
+          const chunkSizeKB = reqArg.chunkSizeKB || 64;
+          const sizeBytes = chunkSizeKB * 1024;
           let payload: string | undefined;
           let bytesTransferred = 0;
 
           switch (reqArg.type) {
-            case 'download':
+            case 'download_chunk':
+              // Generate chunk data for download test
               payload = 'x'.repeat(sizeBytes);
               bytesTransferred = sizeBytes;
               break;
-            case 'upload':
+            case 'upload_chunk':
+              // Acknowledge received upload data
               bytesTransferred = reqArg.payload?.length || 0;
               break;
             case 'latency':
-              bytesTransferred = 1;
+              // Simple ping - minimal data
+              bytesTransferred = 0;
               break;
           }
 
-          const durationMs = Date.now() - startTime;
-          const speedMbps = durationMs > 0 ? (bytesTransferred * 8) / (durationMs * 1000) : 0;
-
-          return { durationMs, bytesTransferred, speedMbps, timestamp: Date.now(), payload };
+          return { bytesTransferred, timestamp: Date.now(), payload };
         })
       );
     } catch (error) {
@@ -381,6 +391,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 +418,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 +501,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 });
   }

ts/controllers/controller.builtin.ts

@@ -1,4 +1,5 @@
 import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
 
 /**
  * Built-in routes controller for TypedServer
@@ -122,4 +123,105 @@ export class BuiltInRoutesController {
       headers: { 'Content-Type': 'text/plain' },
     });
   }
+
+  @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 {
+      const bundleContent = (await plugins.fsInstance
+        .file(paths.swdashBundlePath)
+        .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 sw-dash bundle:', error);
+      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 });
+    }
+  }
 }

ts/controllers/controller.swtypedrequest.ts

@@ -0,0 +1,46 @@
+import * as plugins from '../plugins.js';
+
+/**
+ * SW-TypedRequest controller for service worker type-safe RPC endpoint
+ * This provides a separate endpoint for service worker communication
+ */
+@plugins.smartserve.Route('/sw-typedrequest')
+export class SwTypedRequestController {
+  private typedRouter: plugins.typedrequest.TypedRouter;
+
+  constructor(typedRouter: plugins.typedrequest.TypedRouter) {
+    this.typedRouter = typedRouter;
+  }
+
+  @plugins.smartserve.Post('/')
+  async handleSwTypedRequest(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    try {
+      const response = await this.typedRouter.routeAndAddResponse(ctx.body as plugins.typedrequestInterfaces.ITypedRequest);
+
+      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',
+        },
+      });
+    }
+  }
+
+  @plugins.smartserve.Head('/')
+  async handleSwTypedRequestHead(): Promise<Response> {
+    // HEAD request for online checking from service worker
+    return new Response(null, {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+  }
+}

ts/controllers/index.ts

@@ -1,3 +1,4 @@
 export * from './controller.devtools.js';
 export * from './controller.typedrequest.js';
+export * from './controller.swtypedrequest.js';
 export * from './controller.builtin.js';

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

ts/paths.ts

@@ -8,4 +8,8 @@ export const packageDir = plugins.path.join(
 export const injectBundleDir = plugins.path.join(packageDir, './dist_ts_web_inject');
 export const injectBundlePath = plugins.path.join(injectBundleDir, './bundle.js');
 
-export const serviceworkerBundleDir = plugins.path.join(packageDir, './dist_ts_web_serviceworker');
+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');

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

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

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

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

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

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

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

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

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

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

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

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

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

ts/servertools/tools.serviceworker.ts

@@ -1,141 +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
-      typedrouter.addTypedHandler(
-        new plugins.typedrequest.TypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Speedtest>(
-          'serviceworker_speedtest',
-          async (reqArg) => {
-            const startTime = Date.now();
-            const payloadSizeKB = reqArg.payloadSizeKB || 100;
-            const sizeBytes = payloadSizeKB * 1024;
-            let payload: string | undefined;
-            let bytesTransferred = 0;
-
-            switch (reqArg.type) {
-              case 'download':
-                // Generate random payload for download test
-                payload = 'x'.repeat(sizeBytes);
-                bytesTransferred = sizeBytes;
-                break;
-              case 'upload':
-                // For upload, measure bytes received from client
-                bytesTransferred = reqArg.payload?.length || 0;
-                break;
-              case 'latency':
-                // Minimal payload for latency test
-                bytesTransferred = 1;
-                break;
-            }
-
-            const durationMs = Date.now() - startTime;
-            // Speed in Mbps: (bytes * 8 bits/byte) / (ms * 1000 to get seconds) / 1,000,000 for Mbps
-            const speedMbps = durationMs > 0 ? (bytesTransferred * 8) / (durationMs * 1000) : 0;
-
-            return {
-              durationMs,
-              bytesTransferred,
-              speedMbps,
-              timestamp: Date.now(),
-              payload, // Only for download 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' },
-      });
-    }
-  });
-};

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

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

ts_interfaces/serviceworker.ts

@@ -215,6 +215,14 @@ export interface IRequest_Serviceworker_CacheInvalidate
 
 /**
  * Speedtest request between service worker and backend
+ *
+ * Types:
+ * - 'latency': Simple ping to measure round-trip time
+ * - 'download_chunk': Request a chunk of data (64KB default)
+ * - 'upload_chunk': Send a chunk of data to server
+ *
+ * The client runs a loop calling download_chunk or upload_chunk
+ * until the desired test duration (e.g., 5 seconds) elapses.
  */
 export interface IRequest_Serviceworker_Speedtest
   extends plugins.typedrequestInterfaces.implementsTR<
@@ -223,15 +231,411 @@ export interface IRequest_Serviceworker_Speedtest
   > {
   method: 'serviceworker_speedtest';
   request: {
-    type: 'download' | 'upload' | 'latency';
-    payloadSizeKB?: number;  // Size of test payload in KB (default: 100)
-    payload?: string;        // For upload tests, the payload to send
+    type: 'latency' | 'download_chunk' | 'upload_chunk';
+    chunkSizeKB?: number;    // Size of chunk in KB (default: 64)
+    payload?: string;        // For upload_chunk, the data to send
   };
   response: {
-    durationMs: number;
     bytesTransferred: number;
-    speedMbps: number;
     timestamp: number;
-    payload?: string;        // For download tests, the payload received
+    payload?: string;        // For download_chunk, the data received
   };
-}
+}
+
+// ===============
+// Status update interfaces
+// ===============
+
+/**
+ * Status update source types
+ */
+export type TStatusSource = 'backend' | 'serviceworker' | 'network';
+
+/**
+ * Status update event types
+ */
+export type TStatusType = 'connected' | 'disconnected' | 'reconnecting' | 'update' | 'cache' | 'error' | 'offline' | 'online';
+
+/**
+ * Status update details
+ */
+export interface IStatusDetails {
+  version?: string;
+  cacheHitRate?: number;
+  resourceCount?: number;
+  connectionType?: string;
+  latencyMs?: number;
+  message?: string;
+}
+
+/**
+ * Status update payload sent from SW to clients
+ */
+export interface IStatusUpdate {
+  source: TStatusSource;
+  type: TStatusType;
+  message: string;
+  details?: IStatusDetails;
+  persist?: boolean;  // Stay visible until resolved
+  timestamp: number;
+}
+
+/**
+ * Message for status updates from service worker to clients
+ */
+export interface IMessage_Serviceworker_StatusUpdate
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IMessage_Serviceworker_StatusUpdate
+  > {
+  method: 'serviceworker_statusUpdate';
+  request: IStatusUpdate;
+  response: {};
+}
+
+/**
+ * Request to get current service worker status
+ */
+export interface IRequest_Serviceworker_GetStatus
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_GetStatus
+  > {
+  method: 'serviceworker_getStatus';
+  request: {};
+  response: {
+    isActive: boolean;
+    isOnline: boolean;
+    version?: string;
+    cacheHitRate: number;
+    resourceCount: number;
+    connectionType?: string;
+    connectedClients: number;
+    lastUpdateCheck: number;
+  };
+}
+
+// ===============
+// Persistent Store interfaces
+// ===============
+
+/**
+ * Event types for the persistent event log
+ */
+export type TEventType =
+  | 'sw_installed'
+  | 'sw_activated'
+  | 'sw_updated'
+  | 'sw_stopped'
+  | 'speedtest_started'
+  | 'speedtest_completed'
+  | 'speedtest_failed'
+  | 'backend_connected'
+  | 'backend_disconnected'
+  | 'cache_invalidated'
+  | 'network_online'
+  | 'network_offline'
+  | 'update_check'
+  | 'error';
+
+/**
+ * Event log entry structure
+ * Survives both SW restarts AND cache invalidation
+ */
+export interface IEventLogEntry {
+  id: string;
+  timestamp: number;
+  type: TEventType;
+  message: string;
+  details?: Record<string, any>;
+}
+
+/**
+ * Cumulative metrics that persist across SW restarts
+ * Reset on cache invalidation
+ */
+export interface ICumulativeMetrics {
+  firstSeenTimestamp: number;
+  totalCacheHits: number;
+  totalCacheMisses: number;
+  totalCacheErrors: number;
+  totalBytesServedFromCache: number;
+  totalBytesFetched: number;
+  totalNetworkRequests: number;
+  totalNetworkSuccesses: number;
+  totalNetworkFailures: number;
+  totalNetworkTimeouts: number;
+  totalBytesTransferred: number;
+  totalUpdateChecks: number;
+  totalUpdatesApplied: number;
+  totalSpeedtests: number;
+  swRestartCount: number;
+  lastUpdatedTimestamp: number;
+}
+
+/**
+ * Request to get event log from service worker
+ */
+export interface IRequest_Serviceworker_GetEventLog
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_GetEventLog
+  > {
+  method: 'serviceworker_getEventLog';
+  request: {
+    limit?: number;
+    type?: TEventType;
+    since?: number;
+    before?: number;  // For pagination: get events before this timestamp
+  };
+  response: {
+    events: IEventLogEntry[];
+    totalCount: number;
+  };
+}
+
+/**
+ * Request to get cumulative metrics from service worker
+ */
+export interface IRequest_Serviceworker_GetCumulativeMetrics
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_GetCumulativeMetrics
+  > {
+  method: 'serviceworker_getCumulativeMetrics';
+  request: {};
+  response: ICumulativeMetrics;
+}
+
+/**
+ * Request to clear event log
+ */
+export interface IRequest_Serviceworker_ClearEventLog
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_ClearEventLog
+  > {
+  method: 'serviceworker_clearEventLog';
+  request: {};
+  response: {
+    success: boolean;
+  };
+}
+
+/**
+ * Request to get event count since a timestamp
+ */
+export interface IRequest_Serviceworker_GetEventCount
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_GetEventCount
+  > {
+  method: 'serviceworker_getEventCount';
+  request: {
+    since: number;
+  };
+  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>`;

ts_swdash/index.ts

@@ -0,0 +1,13 @@
+// SW-Dash: Service Worker Dashboard
+// Entry point for the Lit-based dashboard application
+
+// Import the main app component (which imports all others)
+import './sw-dash-app.js';
+
+// Export components for external use if needed
+export { SwDashApp } from './sw-dash-app.js';
+export { SwDashOverview } from './sw-dash-overview.js';
+export { SwDashTable } from './sw-dash-table.js';
+export { SwDashUrls } from './sw-dash-urls.js';
+export { SwDashDomains } from './sw-dash-domains.js';
+export { SwDashTypes } from './sw-dash-types.js';

ts_swdash/plugins.ts

@@ -0,0 +1,19 @@
+// Lit imports
+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,
+  css,
+  customElement,
+  property,
+  state,
+  deesComms,
+};
+
+export type { CSSResult, TemplateResult };

ts_swdash/sw-dash-app.ts

@@ -0,0 +1,582 @@
+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';
+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' | 'requests';
+
+interface IResourceData {
+  resources: ICachedResource[];
+  domains: IDomainStats[];
+  contentTypes: IContentTypeStats[];
+  resourceCount: number;
+}
+
+/**
+ * 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 {
+  public static styles: CSSResult[] = [
+    sharedStyles,
+    terminalStyles,
+    navStyles,
+    css`
+      :host {
+        display: block;
+        background: var(--bg-primary);
+        min-height: 100vh;
+        padding: var(--space-5);
+      }
+
+      .view {
+        display: none;
+      }
+
+      .view.active {
+        display: block;
+      }
+
+      .header-left {
+        display: flex;
+        align-items: center;
+        gap: var(--space-3);
+      }
+
+      .logo {
+        width: 24px;
+        height: 24px;
+        background: var(--accent-primary);
+        border-radius: var(--radius-sm);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-weight: 700;
+        font-size: 12px;
+        color: white;
+      }
+
+      .uptime-badge {
+        display: inline-flex;
+        align-items: center;
+        gap: var(--space-1);
+        padding: var(--space-1) var(--space-2);
+        background: var(--bg-tertiary);
+        border-radius: var(--radius-sm);
+        font-size: 11px;
+        color: var(--text-tertiary);
+      }
+
+      .uptime-badge .value {
+        color: var(--text-primary);
+        font-weight: 500;
+        font-variant-numeric: tabular-nums;
+      }
+
+      .footer-left {
+        display: flex;
+        align-items: center;
+        gap: var(--space-2);
+        color: var(--text-tertiary);
+        font-size: 11px;
+      }
+
+      .footer-right {
+        display: flex;
+        align-items: center;
+        gap: var(--space-2);
+      }
+
+      .auto-refresh {
+        display: inline-flex;
+        align-items: center;
+        gap: var(--space-1);
+        padding: var(--space-1) var(--space-2);
+        background: rgba(34, 197, 94, 0.1);
+        color: var(--accent-success);
+        border-radius: var(--radius-sm);
+        font-size: 11px;
+        font-weight: 500;
+      }
+
+      .auto-refresh .dot {
+        width: 5px;
+        height: 5px;
+        border-radius: 50%;
+        background: currentColor;
+        animation: pulse 2s infinite;
+      }
+
+      @keyframes pulse {
+        0%, 100% { opacity: 1; }
+        50% { opacity: 0.4; }
+      }
+    `
+  ];
+
+  // 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
+  };
+
+  // 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();
+    // 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.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+    }
+  }
+
+  /**
+   * 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');
+      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 initial data:', err);
+      this.isConnected = false;
+    }
+  }
+
+  /**
+   * 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 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 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;
+    // No HTTP fetch on view change - data is already loaded from initial seed
+  }
+
+  private handleSpeedtestComplete(_e: CustomEvent): void {
+    // Refresh metrics after speedtest via HTTP
+    this.loadInitialData();
+  }
+
+  private formatUptime(ms: number): string {
+    const s = Math.floor(ms / 1000);
+    const m = Math.floor(s / 60);
+    const h = Math.floor(m / 60);
+    const d = Math.floor(h / 24);
+    if (d > 0) return `${d}d ${h % 24}h`;
+    if (h > 0) return `${h}h ${m % 60}m`;
+    if (m > 0) return `${m}m ${s % 60}s`;
+    return `${s}s`;
+  }
+
+  public render(): TemplateResult {
+    return html`
+      <div class="terminal">
+        <div class="header">
+          <div class="header-left">
+            <div class="logo">SW</div>
+            <span class="title">Service Worker Dashboard</span>
+          </div>
+          <div class="uptime-badge">
+            Uptime: <span class="value">${this.metrics ? this.formatUptime(this.metrics.uptime) : '--'}</span>
+          </div>
+        </div>
+
+        <nav class="nav">
+          <button
+            class="nav-tab ${this.currentView === 'overview' ? 'active' : ''}"
+            @click="${() => this.setView('overview')}"
+          >Overview</button>
+          <button
+            class="nav-tab ${this.currentView === 'urls' ? 'active' : ''}"
+            @click="${() => this.setView('urls')}"
+          >URLs <span class="count">${this.resourceData.resourceCount}</span></button>
+          <button
+            class="nav-tab ${this.currentView === 'domains' ? 'active' : ''}"
+            @click="${() => this.setView('domains')}"
+          >Domains</button>
+          <button
+            class="nav-tab ${this.currentView === 'types' ? 'active' : ''}"
+            @click="${() => this.setView('types')}"
+          >Types</button>
+          <button
+            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>
+
+          <div class="view ${this.currentView === 'urls' ? 'active' : ''}">
+            <sw-dash-urls .resources="${this.resourceData.resources}"></sw-dash-urls>
+          </div>
+
+          <div class="view ${this.currentView === 'domains' ? 'active' : ''}">
+            <sw-dash-domains .domains="${this.resourceData.domains}"></sw-dash-domains>
+          </div>
+
+          <div class="view ${this.currentView === 'types' ? 'active' : ''}">
+            <sw-dash-types .contentTypes="${this.resourceData.contentTypes}"></sw-dash-types>
+          </div>
+
+          <div class="view ${this.currentView === 'events' ? 'active' : ''}">
+            <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>
+
+        <div class="footer">
+          <div class="footer-left">
+            Last updated: ${this.lastRefresh}
+          </div>
+          <div class="footer-right">
+            <div class="auto-refresh">
+              <span class="dot"></span>
+              Live
+            </div>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+}

ts_swdash/sw-dash-domains.ts

@@ -0,0 +1,52 @@
+import { LitElement, html, css, property, customElement } from './plugins.js';
+import type { CSSResult, TemplateResult } from './plugins.js';
+import { sharedStyles, tableStyles } from './sw-dash-styles.js';
+import { SwDashTable } from './sw-dash-table.js';
+import type { IColumnConfig } from './sw-dash-table.js';
+
+export interface IDomainStats {
+  domain: string;
+  totalResources: number;
+  totalSize: number;
+  totalHits: number;
+  totalMisses: number;
+  hitRate: number;
+}
+
+/**
+ * Domains table view component
+ */
+@customElement('sw-dash-domains')
+export class SwDashDomains extends LitElement {
+  public static styles: CSSResult[] = [
+    sharedStyles,
+    tableStyles,
+    css`
+      :host {
+        display: block;
+      }
+    `
+  ];
+
+  @property({ type: Array }) accessor domains: IDomainStats[] = [];
+
+  private columns: IColumnConfig[] = [
+    { key: 'domain', label: 'Domain' },
+    { key: 'totalResources', label: 'Resources', className: 'num', formatter: SwDashTable.formatNumber },
+    { key: 'totalSize', label: 'Total Size', className: 'num', formatter: SwDashTable.formatBytes },
+    { key: 'totalHits', label: 'Hits', className: 'num', formatter: SwDashTable.formatNumber },
+    { key: 'totalMisses', label: 'Misses', className: 'num', formatter: SwDashTable.formatNumber },
+    { key: 'hitRate', label: 'Hit Rate' },
+  ];
+
+  public render(): TemplateResult {
+    return html`
+      <sw-dash-table
+        .columns="${this.columns}"
+        .data="${this.domains}"
+        filterPlaceholder="Filter domains..."
+        infoLabel="domains"
+      ></sw-dash-table>
+    `;
+  }
+}

ts_swdash/sw-dash-events.ts

@@ -0,0 +1,359 @@
+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 IEventLogEntry {
+  id: string;
+  timestamp: number;
+  type: string;
+  message: string;
+  details?: Record<string, any>;
+}
+
+type TEventFilter = 'all' | 'sw_installed' | 'sw_activated' | 'sw_updated' | 'sw_stopped'
+  | 'speedtest_started' | 'speedtest_completed' | 'speedtest_failed'
+  | 'backend_connected' | 'backend_disconnected'
+  | 'cache_invalidated' | 'network_online' | 'network_offline'
+  | 'update_check' | 'error';
+
+/**
+ * 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 {
+  public static styles: CSSResult[] = [
+    sharedStyles,
+    panelStyles,
+    tableStyles,
+    buttonStyles,
+    css`
+      :host {
+        display: block;
+      }
+
+      .events-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);
+      }
+
+      .events-list {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-2);
+        max-height: 600px;
+        overflow-y: auto;
+      }
+
+      .event-card {
+        background: var(--bg-secondary);
+        border: 1px solid var(--border-default);
+        border-radius: var(--radius-md);
+        padding: var(--space-3);
+      }
+
+      .event-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: flex-start;
+        margin-bottom: var(--space-2);
+      }
+
+      .event-type {
+        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;
+      }
+
+      .event-type.sw { background: rgba(99, 102, 241, 0.15); color: var(--accent-primary); }
+      .event-type.speedtest { background: rgba(59, 130, 246, 0.15); color: #3b82f6; }
+      .event-type.network { background: rgba(34, 197, 94, 0.15); color: var(--accent-success); }
+      .event-type.cache { background: rgba(251, 191, 36, 0.15); color: var(--accent-warning); }
+      .event-type.error { background: rgba(239, 68, 68, 0.15); color: var(--accent-error); }
+
+      .event-time {
+        font-size: 11px;
+        color: var(--text-tertiary);
+        font-variant-numeric: tabular-nums;
+      }
+
+      .event-message {
+        font-size: 13px;
+        color: var(--text-primary);
+        margin-bottom: var(--space-2);
+      }
+
+      .event-details {
+        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;
+      }
+
+      .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);
+      }
+
+      .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-label {
+        font-size: 11px;
+        color: var(--text-tertiary);
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+      }
+
+      .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);
+      }
+    `
+  ];
+
+  // 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 isLoadingMore = false;
+
+  private handleFilterChange(e: Event): void {
+    this.filter = (e.target as HTMLSelectElement).value as TEventFilter;
+    // 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 event log? This cannot be undone.')) {
+      return;
+    }
+    // Dispatch event to parent to clear via DeesComms
+    this.dispatchEvent(new CustomEvent('clear-events', {
+      bubbles: true,
+      composed: true,
+    }));
+  }
+
+  private loadMore(): void {
+    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 {
+    if (type.startsWith('sw_')) return 'sw';
+    if (type.startsWith('speedtest_')) return 'speedtest';
+    if (type.startsWith('network_') || type.startsWith('backend_')) return 'network';
+    if (type.startsWith('cache_') || type === 'update_check') return 'cache';
+    if (type === 'error') return 'error';
+    return 'sw';
+  }
+
+  private formatTimestamp(ts: number): string {
+    const date = new Date(ts);
+    return date.toLocaleString();
+  }
+
+  private formatTypeLabel(type: string): string {
+    return type.replace(/_/g, ' ');
+  }
+
+  /**
+   * Filter events locally based on type and search text
+   */
+  private getFilteredEvents(): IEventLogEntry[] {
+    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 {
+    const filteredEvents = this.getFilteredEvents();
+
+    return html`
+      <div class="stats-bar">
+        <div class="stat-item">
+          <span class="stat-value">${this.totalCount}</span>
+          <span class="stat-label">Total Events</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">${filteredEvents.length}</span>
+          <span class="stat-label">Showing</span>
+        </div>
+      </div>
+
+      <div class="events-header">
+        <div class="filter-group">
+          <span class="filter-label">Filter:</span>
+          <select class="filter-select" @change="${this.handleFilterChange}">
+            <option value="all">All Events</option>
+            <option value="sw_installed">SW Installed</option>
+            <option value="sw_activated">SW Activated</option>
+            <option value="sw_updated">SW Updated</option>
+            <option value="speedtest_started">Speedtest Started</option>
+            <option value="speedtest_completed">Speedtest Completed</option>
+            <option value="speedtest_failed">Speedtest Failed</option>
+            <option value="network_online">Network Online</option>
+            <option value="network_offline">Network Offline</option>
+            <option value="cache_invalidated">Cache Invalidated</option>
+            <option value="error">Errors</option>
+          </select>
+          <input
+            type="text"
+            class="search-input"
+            placeholder="Search events..."
+            .value="${this.searchText}"
+            @input="${this.handleSearch}"
+            style="width: 200px;"
+          >
+        </div>
+        <button class="btn clear-btn" @click="${this.handleClear}">Clear Log</button>
+      </div>
+
+      ${this.events.length === 0 ? html`
+        <div class="empty-state">No events recorded</div>
+      ` : filteredEvents.length === 0 ? html`
+        <div class="empty-state">No events match filter</div>
+      ` : html`
+        <div class="events-list">
+          ${filteredEvents.map(event => html`
+            <div class="event-card">
+              <div class="event-header">
+                <span class="event-type ${this.getTypeClass(event.type)}">${this.formatTypeLabel(event.type)}</span>
+                <span class="event-time">${this.formatTimestamp(event.timestamp)}</span>
+              </div>
+              <div class="event-message">${event.message}</div>
+              ${event.details ? html`
+                <div class="event-details">${JSON.stringify(event.details, null, 2)}</div>
+              ` : ''}
+            </div>
+          `)}
+        </div>
+
+        ${this.events.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.events.length} of ${this.totalCount} events</span>
+          </div>
+        ` : ''}
+      `}
+    `;
+  }
+}

ts_swdash/sw-dash-overview.ts

@@ -0,0 +1,291 @@
+import { LitElement, html, css, property, state, customElement } from './plugins.js';
+import type { CSSResult, TemplateResult } from './plugins.js';
+import { sharedStyles, panelStyles, gaugeStyles, buttonStyles, speedtestStyles } from './sw-dash-styles.js';
+import { SwDashTable } from './sw-dash-table.js';
+
+export interface IMetricsData {
+  cache: {
+    hits: number;
+    misses: number;
+    errors: number;
+    bytesServedFromCache: number;
+    bytesFetched: number;
+    averageResponseTime: number;
+  };
+  network: {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    timeouts: number;
+    averageLatency: number;
+    totalBytesTransferred: number;
+  };
+  update: {
+    totalChecks: number;
+    successfulChecks: number;
+    failedChecks: number;
+    updatesFound: number;
+    updatesApplied: number;
+    lastCheckTimestamp: number;
+    lastUpdateTimestamp: number;
+  };
+  connection: {
+    connectedClients: number;
+    totalConnectionAttempts: number;
+    successfulConnections: number;
+    failedConnections: number;
+  };
+  speedtest: {
+    lastDownloadSpeedMbps: number;
+    lastUploadSpeedMbps: number;
+    lastLatencyMs: number;
+    lastTestTimestamp: number;
+    testCount: number;
+    isOnline: boolean;
+  };
+  startTime: number;
+  uptime: number;
+  cacheHitRate: number;
+  networkSuccessRate: number;
+  resourceCount: number;
+}
+
+/**
+ * Overview panel component with metrics gauges and stats
+ */
+@customElement('sw-dash-overview')
+export class SwDashOverview extends LitElement {
+  public static styles: CSSResult[] = [
+    sharedStyles,
+    panelStyles,
+    gaugeStyles,
+    buttonStyles,
+    speedtestStyles,
+    css`
+      :host {
+        display: block;
+      }
+
+      .panel-content {
+        padding: var(--space-4);
+      }
+
+      .section-divider {
+        margin-top: var(--space-4);
+        padding-top: var(--space-4);
+        border-top: 1px solid var(--border-muted);
+      }
+    `
+  ];
+
+  @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;
+
+  // Speedtest timing constants (must match service worker)
+  private static readonly TEST_DURATION_MS = 5000;  // 5 seconds per test
+  private progressInterval: number | null = null;
+
+  private async runSpeedtest(): Promise<void> {
+    if (this.speedtestRunning) return;
+    this.speedtestRunning = true;
+    this.speedtestPhase = 'latency';
+    this.speedtestProgress = 0;
+    this.speedtestElapsed = 0;
+
+    // Start progress animation (total ~10.5s: latency ~0.5s + 5s download + 5s upload)
+    const totalEstimatedMs = 10500;
+    const startTime = Date.now();
+
+    this.progressInterval = window.setInterval(() => {
+      this.speedtestElapsed = Date.now() - startTime;
+      this.speedtestProgress = Math.min(100, (this.speedtestElapsed / totalEstimatedMs) * 100);
+
+      // Estimate phase based on elapsed time
+      if (this.speedtestElapsed < 500) {
+        this.speedtestPhase = 'latency';
+      } else if (this.speedtestElapsed < 5500) {
+        this.speedtestPhase = 'download';
+      } else {
+        this.speedtestPhase = 'upload';
+      }
+    }, 100);
+
+    try {
+      const response = await fetch('/sw-dash/speedtest');
+      const result = await response.json();
+
+      this.speedtestPhase = 'complete';
+      this.speedtestProgress = 100;
+
+      // Dispatch event to parent to update metrics
+      this.dispatchEvent(new CustomEvent('speedtest-complete', {
+        detail: result,
+        bubbles: true,
+        composed: true
+      }));
+    } catch (err) {
+      console.error('Speedtest failed:', err);
+      this.speedtestPhase = 'idle';
+    } finally {
+      if (this.progressInterval) {
+        window.clearInterval(this.progressInterval);
+        this.progressInterval = null;
+      }
+      // Keep showing complete state briefly, then reset
+      setTimeout(() => {
+        this.speedtestRunning = false;
+        this.speedtestPhase = 'idle';
+        this.speedtestProgress = 0;
+      }, 1500);
+    }
+  }
+
+  private getPhaseLabel(): string {
+    switch (this.speedtestPhase) {
+      case 'latency': return 'Testing latency';
+      case 'download': return 'Download test';
+      case 'upload': return 'Upload test';
+      case 'complete': return 'Complete';
+      default: return '';
+    }
+  }
+
+  private formatElapsed(): string {
+    const seconds = Math.floor(this.speedtestElapsed / 1000);
+    return `${seconds}s`;
+  }
+
+  public render(): TemplateResult {
+    if (!this.metrics) {
+      return html`<div class="panel"><div class="panel-content">Loading metrics...</div></div>`;
+    }
+
+    const m = this.metrics;
+    const gaugeClass = SwDashTable.getGaugeClass;
+
+    return html`
+      <div class="grid">
+        <!-- Cache Panel -->
+        <div class="panel">
+          <div class="panel-title">Cache</div>
+          <div class="panel-content">
+            <div class="gauge">
+              <div class="gauge-header">
+                <span class="gauge-label">Hit Rate</span>
+                <span class="gauge-value">${m.cacheHitRate}%</span>
+              </div>
+              <div class="gauge-bar">
+                <div class="gauge-fill ${gaugeClass(m.cacheHitRate)}" style="width: ${m.cacheHitRate}%"></div>
+              </div>
+            </div>
+            <div class="row"><span class="label">Hits</span><span class="value success">${SwDashTable.formatNumber(m.cache.hits)}</span></div>
+            <div class="row"><span class="label">Misses</span><span class="value warning">${SwDashTable.formatNumber(m.cache.misses)}</span></div>
+            <div class="row"><span class="label">Errors</span><span class="value ${m.cache.errors > 0 ? 'error' : ''}">${SwDashTable.formatNumber(m.cache.errors)}</span></div>
+            <div class="row"><span class="label">From Cache</span><span class="value">${SwDashTable.formatBytes(m.cache.bytesServedFromCache)}</span></div>
+            <div class="row"><span class="label">Fetched</span><span class="value">${SwDashTable.formatBytes(m.cache.bytesFetched)}</span></div>
+            <div class="row"><span class="label">Resources</span><span class="value">${m.resourceCount}</span></div>
+          </div>
+        </div>
+
+        <!-- Network Panel -->
+        <div class="panel">
+          <div class="panel-title">Network</div>
+          <div class="panel-content">
+            <div class="gauge">
+              <div class="gauge-header">
+                <span class="gauge-label">Success Rate</span>
+                <span class="gauge-value">${m.networkSuccessRate}%</span>
+              </div>
+              <div class="gauge-bar">
+                <div class="gauge-fill ${gaugeClass(m.networkSuccessRate)}" style="width: ${m.networkSuccessRate}%"></div>
+              </div>
+            </div>
+            <div class="row"><span class="label">Total Requests</span><span class="value">${SwDashTable.formatNumber(m.network.totalRequests)}</span></div>
+            <div class="row"><span class="label">Successful</span><span class="value success">${SwDashTable.formatNumber(m.network.successfulRequests)}</span></div>
+            <div class="row"><span class="label">Failed</span><span class="value ${m.network.failedRequests > 0 ? 'error' : ''}">${SwDashTable.formatNumber(m.network.failedRequests)}</span></div>
+            <div class="row"><span class="label">Timeouts</span><span class="value ${m.network.timeouts > 0 ? 'warning' : ''}">${SwDashTable.formatNumber(m.network.timeouts)}</span></div>
+            <div class="row"><span class="label">Avg Latency</span><span class="value">${m.network.averageLatency}ms</span></div>
+            <div class="row"><span class="label">Transferred</span><span class="value">${SwDashTable.formatBytes(m.network.totalBytesTransferred)}</span></div>
+          </div>
+        </div>
+
+        <!-- Updates Panel -->
+        <div class="panel">
+          <div class="panel-title">Updates</div>
+          <div class="panel-content">
+            <div class="row"><span class="label">Total Checks</span><span class="value">${SwDashTable.formatNumber(m.update.totalChecks)}</span></div>
+            <div class="row"><span class="label">Successful</span><span class="value success">${SwDashTable.formatNumber(m.update.successfulChecks)}</span></div>
+            <div class="row"><span class="label">Failed</span><span class="value ${m.update.failedChecks > 0 ? 'error' : ''}">${SwDashTable.formatNumber(m.update.failedChecks)}</span></div>
+            <div class="row"><span class="label">Updates Found</span><span class="value">${SwDashTable.formatNumber(m.update.updatesFound)}</span></div>
+            <div class="row"><span class="label">Updates Applied</span><span class="value success">${SwDashTable.formatNumber(m.update.updatesApplied)}</span></div>
+            <div class="row"><span class="label">Last Check</span><span class="value">${SwDashTable.formatTimestamp(m.update.lastCheckTimestamp)}</span></div>
+          </div>
+        </div>
+
+        <!-- Connections Panel -->
+        <div class="panel">
+          <div class="panel-title">Connections</div>
+          <div class="panel-content">
+            <div class="row"><span class="label">Active Clients</span><span class="value success">${SwDashTable.formatNumber(m.connection.connectedClients)}</span></div>
+            <div class="row"><span class="label">Total Attempts</span><span class="value">${SwDashTable.formatNumber(m.connection.totalConnectionAttempts)}</span></div>
+            <div class="row"><span class="label">Successful</span><span class="value success">${SwDashTable.formatNumber(m.connection.successfulConnections)}</span></div>
+            <div class="row"><span class="label">Failed</span><span class="value ${m.connection.failedConnections > 0 ? 'error' : ''}">${SwDashTable.formatNumber(m.connection.failedConnections)}</span></div>
+            <div class="section-divider">
+              <div class="row"><span class="label">Events (1h)</span><span class="value">${this.eventCountLastHour}</span></div>
+              <div class="row"><span class="label">Started</span><span class="value">${SwDashTable.formatTimestamp(m.startTime)}</span></div>
+            </div>
+          </div>
+        </div>
+
+        <!-- Speedtest Panel -->
+        <div class="panel">
+          <div class="panel-title">Speedtest</div>
+          <div class="panel-content">
+            <div class="online-indicator ${m.speedtest.isOnline ? 'online' : 'offline'}">
+              <span class="online-dot"></span>
+              <span>${m.speedtest.isOnline ? 'Online' : 'Offline'}</span>
+            </div>
+            ${this.speedtestRunning ? html`
+              <div class="speedtest-progress">
+                <div class="progress-header">
+                  <span class="progress-phase">${this.getPhaseLabel()}</span>
+                  <span class="progress-time">${this.formatElapsed()}</span>
+                </div>
+                <div class="progress-bar">
+                  <div class="progress-fill ${this.speedtestPhase === 'complete' ? 'complete' : ''}" style="width: ${this.speedtestProgress}%"></div>
+                </div>
+              </div>
+            ` : html`
+              <div class="speedtest-results">
+                <div class="speedtest-metric">
+                  <div class="speedtest-value">${m.speedtest.lastDownloadSpeedMbps.toFixed(1)}</div>
+                  <div class="speedtest-unit">Mbps</div>
+                  <div class="speedtest-label">Download</div>
+                </div>
+                <div class="speedtest-metric">
+                  <div class="speedtest-value">${m.speedtest.lastUploadSpeedMbps.toFixed(1)}</div>
+                  <div class="speedtest-unit">Mbps</div>
+                  <div class="speedtest-label">Upload</div>
+                </div>
+                <div class="speedtest-metric">
+                  <div class="speedtest-value">${m.speedtest.lastLatencyMs.toFixed(0)}</div>
+                  <div class="speedtest-unit">ms</div>
+                  <div class="speedtest-label">Latency</div>
+                </div>
+              </div>
+            `}
+            <div class="btn-row">
+              <button class="btn btn-secondary" ?disabled="${this.speedtestRunning}" @click="${this.runSpeedtest}">
+                ${this.speedtestRunning ? 'Testing...' : 'Run Test'}
+              </button>
+            </div>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+}

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

ts_swdash/sw-dash-styles.ts

@@ -0,0 +1,667 @@
+import { css } from './plugins.js';
+import type { CSSResult } from './plugins.js';
+
+/**
+ * Modern professional theme for sw-dash components
+ * Inspired by Bloomberg terminals, Vercel dashboards, and shadcn/ui
+ */
+export const sharedStyles: CSSResult = css`
+  :host {
+    /* Neutral backgrounds - zinc scale */
+    --bg-primary: #09090b;
+    --bg-secondary: #18181b;
+    --bg-tertiary: #27272a;
+    --bg-elevated: #3f3f46;
+
+    /* Text colors */
+    --text-primary: #fafafa;
+    --text-secondary: #a1a1aa;
+    --text-tertiary: #71717a;
+
+    /* Borders */
+    --border-default: #27272a;
+    --border-muted: #3f3f46;
+
+    /* Accent colors */
+    --accent-primary: #3b82f6;
+    --accent-success: #22c55e;
+    --accent-warning: #eab308;
+    --accent-error: #ef4444;
+    --accent-info: #06b6d4;
+
+    /* Spacing scale */
+    --space-1: 4px;
+    --space-2: 8px;
+    --space-3: 12px;
+    --space-4: 16px;
+    --space-5: 20px;
+    --space-6: 24px;
+    --space-8: 32px;
+
+    /* Border radius */
+    --radius-sm: 4px;
+    --radius-md: 6px;
+    --radius-lg: 8px;
+    --radius-xl: 12px;
+
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    font-size: 13px;
+    line-height: 1.5;
+    color: var(--text-primary);
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+
+  * {
+    box-sizing: border-box;
+  }
+`;
+
+export const terminalStyles: CSSResult = css`
+  .terminal {
+    max-width: 1200px;
+    margin: 0 auto;
+    border: 1px solid var(--border-default);
+    background: var(--bg-primary);
+    border-radius: var(--radius-lg);
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+    overflow: hidden;
+  }
+
+  .header {
+    border-bottom: 1px solid var(--border-default);
+    padding: var(--space-4) var(--space-5);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: var(--bg-secondary);
+  }
+
+  .title {
+    color: var(--text-primary);
+    font-weight: 600;
+    font-size: 14px;
+    letter-spacing: -0.01em;
+  }
+
+  .uptime {
+    color: var(--text-tertiary);
+    font-size: 12px;
+    font-variant-numeric: tabular-nums;
+  }
+
+  .content {
+    padding: var(--space-5);
+    min-height: 400px;
+    background: var(--bg-primary);
+  }
+
+  .footer {
+    border-top: 1px solid var(--border-default);
+    padding: var(--space-3) var(--space-5);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: var(--bg-secondary);
+    font-size: 12px;
+  }
+
+  .refresh-info {
+    color: var(--text-tertiary);
+    font-size: 11px;
+  }
+
+  .status {
+    display: flex;
+    align-items: center;
+    gap: var(--space-2);
+  }
+
+  .status-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--accent-success);
+  }
+
+  .status-dot.offline {
+    background: var(--accent-error);
+  }
+
+  .prompt {
+    color: var(--text-secondary);
+    font-size: 11px;
+  }
+`;
+
+export const navStyles: CSSResult = css`
+  .nav {
+    display: flex;
+    gap: var(--space-1);
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border-default);
+    padding: var(--space-2) var(--space-3);
+  }
+
+  .nav-tab {
+    padding: var(--space-2) var(--space-4);
+    cursor: pointer;
+    color: var(--text-secondary);
+    border: none;
+    background: transparent;
+    font-family: inherit;
+    font-size: 13px;
+    font-weight: 500;
+    transition: all 0.15s ease;
+    border-radius: var(--radius-sm);
+  }
+
+  .nav-tab:hover {
+    color: var(--text-primary);
+    background: var(--bg-tertiary);
+  }
+
+  .nav-tab.active {
+    color: var(--text-primary);
+    background: var(--bg-elevated);
+  }
+
+  .nav-tab .count {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 20px;
+    height: 18px;
+    background: var(--bg-tertiary);
+    padding: 0 6px;
+    border-radius: 9999px;
+    font-size: 11px;
+    font-weight: 500;
+    margin-left: var(--space-2);
+    color: var(--text-secondary);
+  }
+
+  .nav-tab.active .count {
+    background: var(--accent-primary);
+    color: white;
+  }
+`;
+
+export const panelStyles: CSSResult = css`
+  .grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(340px, 1fr));
+    gap: var(--space-4);
+  }
+
+  .panel {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-default);
+    border-radius: var(--radius-lg);
+    overflow: hidden;
+  }
+
+  .panel-title {
+    color: var(--text-secondary);
+    font-weight: 600;
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    padding: var(--space-3) var(--space-4);
+    border-bottom: 1px solid var(--border-default);
+    background: var(--bg-tertiary);
+  }
+
+  .panel-content {
+    padding: var(--space-4);
+  }
+
+  .row {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: var(--space-2) 0;
+    border-bottom: 1px solid var(--border-muted);
+  }
+
+  .row:last-child {
+    border-bottom: none;
+  }
+
+  .label {
+    color: var(--text-secondary);
+    font-size: 13px;
+  }
+
+  .value {
+    color: var(--text-primary);
+    font-weight: 500;
+    font-variant-numeric: tabular-nums;
+  }
+
+  .value.warning {
+    color: var(--accent-warning);
+  }
+
+  .value.error {
+    color: var(--accent-error);
+  }
+
+  .value.success {
+    color: var(--accent-success);
+  }
+`;
+
+export const gaugeStyles: CSSResult = css`
+  .gauge {
+    margin: var(--space-3) 0;
+  }
+
+  .gauge-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--space-2);
+    font-size: 12px;
+  }
+
+  .gauge-label {
+    color: var(--text-secondary);
+  }
+
+  .gauge-value {
+    color: var(--text-primary);
+    font-weight: 600;
+    font-variant-numeric: tabular-nums;
+  }
+
+  .gauge-bar {
+    height: 6px;
+    background: var(--bg-tertiary);
+    border-radius: 3px;
+    overflow: hidden;
+  }
+
+  .gauge-fill {
+    height: 100%;
+    border-radius: 3px;
+    transition: width 0.3s ease;
+  }
+
+  .gauge-fill.good {
+    background: var(--accent-success);
+  }
+
+  .gauge-fill.warning {
+    background: var(--accent-warning);
+  }
+
+  .gauge-fill.bad {
+    background: var(--accent-error);
+  }
+`;
+
+export const tableStyles: CSSResult = css`
+  .table-container {
+    overflow-x: auto;
+    border-radius: var(--radius-md);
+  }
+
+  .data-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 13px;
+  }
+
+  .data-table th {
+    text-align: left;
+    padding: var(--space-3) var(--space-4);
+    background: var(--bg-tertiary);
+    color: var(--text-secondary);
+    font-weight: 500;
+    font-size: 12px;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    cursor: pointer;
+    user-select: none;
+    white-space: nowrap;
+    border-bottom: 1px solid var(--border-default);
+  }
+
+  .data-table th:hover {
+    background: var(--bg-elevated);
+    color: var(--text-primary);
+  }
+
+  .data-table th .sort-icon {
+    margin-left: var(--space-1);
+    opacity: 0.4;
+    font-size: 10px;
+  }
+
+  .data-table th.sorted .sort-icon {
+    opacity: 1;
+    color: var(--accent-primary);
+  }
+
+  .data-table td {
+    padding: var(--space-3) var(--space-4);
+    border-bottom: 1px solid var(--border-default);
+    color: var(--text-primary);
+  }
+
+  .data-table tr:hover td {
+    background: var(--bg-tertiary);
+  }
+
+  .data-table td.url {
+    max-width: 400px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    color: var(--text-secondary);
+    font-family: 'SF Mono', 'Fira Code', 'Consolas', monospace;
+    font-size: 12px;
+  }
+
+  .data-table td.num {
+    text-align: right;
+    font-variant-numeric: tabular-nums;
+    font-weight: 500;
+  }
+
+  .table-controls {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--space-4);
+    gap: var(--space-3);
+  }
+
+  .search-input {
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border-default);
+    color: var(--text-primary);
+    padding: var(--space-2) var(--space-3);
+    font-family: inherit;
+    font-size: 13px;
+    width: 280px;
+    border-radius: var(--radius-md);
+    transition: all 0.15s ease;
+  }
+
+  .search-input::placeholder {
+    color: var(--text-tertiary);
+  }
+
+  .search-input:focus {
+    outline: none;
+    border-color: var(--accent-primary);
+    box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1);
+  }
+
+  .table-info {
+    color: var(--text-tertiary);
+    font-size: 12px;
+  }
+
+  .hit-rate-bar {
+    width: 60px;
+    height: 4px;
+    background: var(--bg-tertiary);
+    border-radius: 2px;
+    display: inline-block;
+    vertical-align: middle;
+    margin-right: var(--space-2);
+    overflow: hidden;
+  }
+
+  .hit-rate-fill {
+    height: 100%;
+    border-radius: 2px;
+  }
+
+  .hit-rate-fill.good {
+    background: var(--accent-success);
+  }
+
+  .hit-rate-fill.warning {
+    background: var(--accent-warning);
+  }
+
+  .hit-rate-fill.bad {
+    background: var(--accent-error);
+  }
+`;
+
+export const buttonStyles: CSSResult = css`
+  .btn {
+    padding: var(--space-2) var(--space-4);
+    border-radius: var(--radius-md);
+    font-family: inherit;
+    font-size: 13px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.15s ease;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--space-2);
+  }
+
+  .btn-primary {
+    background: var(--accent-primary);
+    color: white;
+    border: none;
+  }
+
+  .btn-primary:hover {
+    background: #2563eb;
+  }
+
+  .btn-primary:active {
+    background: #1d4ed8;
+  }
+
+  .btn-secondary {
+    background: var(--bg-tertiary);
+    color: var(--text-primary);
+    border: 1px solid var(--border-default);
+  }
+
+  .btn-secondary:hover {
+    background: var(--bg-elevated);
+    border-color: var(--border-muted);
+  }
+
+  .btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .btn-row {
+    display: flex;
+    justify-content: flex-end;
+    gap: var(--space-2);
+    margin-top: var(--space-4);
+  }
+`;
+
+export const speedtestStyles: CSSResult = css`
+  .online-indicator {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--space-2);
+    padding: var(--space-1) var(--space-3);
+    border-radius: 9999px;
+    font-size: 12px;
+    font-weight: 500;
+    margin-bottom: var(--space-4);
+  }
+
+  .online-indicator.online {
+    background: rgba(34, 197, 94, 0.1);
+    color: var(--accent-success);
+  }
+
+  .online-indicator.offline {
+    background: rgba(239, 68, 68, 0.1);
+    color: var(--accent-error);
+  }
+
+  .online-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: currentColor;
+  }
+
+  .speedtest-results {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: var(--space-4);
+    margin-top: var(--space-4);
+  }
+
+  .speedtest-metric {
+    text-align: center;
+    padding: var(--space-4);
+    background: var(--bg-tertiary);
+    border-radius: var(--radius-md);
+  }
+
+  .speedtest-value {
+    font-size: 24px;
+    font-weight: 600;
+    font-variant-numeric: tabular-nums;
+    color: var(--text-primary);
+    line-height: 1.2;
+  }
+
+  .speedtest-unit {
+    font-size: 12px;
+    color: var(--text-secondary);
+    margin-top: var(--space-1);
+  }
+
+  .speedtest-label {
+    font-size: 11px;
+    color: var(--text-tertiary);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-top: var(--space-2);
+  }
+
+  .speed-bar {
+    height: 4px;
+    background: var(--bg-tertiary);
+    border-radius: 2px;
+    margin: var(--space-1) 0;
+    overflow: hidden;
+  }
+
+  .speed-fill {
+    height: 100%;
+    background: var(--accent-success);
+    border-radius: 2px;
+    transition: width 0.5s ease;
+  }
+
+  /* Speedtest progress indicator */
+  .speedtest-progress {
+    padding: var(--space-4) 0;
+  }
+
+  .progress-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--space-3);
+  }
+
+  .progress-phase {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--space-2);
+    color: var(--accent-info);
+    font-weight: 500;
+    font-size: 13px;
+  }
+
+  .progress-phase::before {
+    content: '';
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: currentColor;
+    animation: pulse 1s infinite;
+  }
+
+  .progress-time {
+    color: var(--text-tertiary);
+    font-size: 12px;
+    font-variant-numeric: tabular-nums;
+  }
+
+  .progress-bar {
+    height: 6px;
+    background: var(--bg-tertiary);
+    border-radius: 3px;
+    overflow: hidden;
+  }
+
+  .progress-fill {
+    height: 100%;
+    background: var(--accent-info);
+    border-radius: 3px;
+    transition: width 0.1s linear;
+  }
+
+  .progress-fill.complete {
+    background: var(--accent-success);
+  }
+
+  @keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+  }
+`;
+
+export const statusBadgeStyles: CSSResult = css`
+  .status-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--space-1);
+    padding: var(--space-1) var(--space-2);
+    border-radius: 9999px;
+    font-size: 11px;
+    font-weight: 500;
+  }
+
+  .status-badge.success {
+    background: rgba(34, 197, 94, 0.1);
+    color: var(--accent-success);
+  }
+
+  .status-badge.warning {
+    background: rgba(234, 179, 8, 0.1);
+    color: var(--accent-warning);
+  }
+
+  .status-badge.error {
+    background: rgba(239, 68, 68, 0.1);
+    color: var(--accent-error);
+  }
+
+  .status-badge.info {
+    background: rgba(6, 182, 212, 0.1);
+    color: var(--accent-info);
+  }
+
+  .status-badge .badge-dot {
+    width: 5px;
+    height: 5px;
+    border-radius: 50%;
+    background: currentColor;
+  }
+`;

ts_swdash/sw-dash-table.ts

@@ -0,0 +1,173 @@
+import { LitElement, html, css, property, state, customElement } from './plugins.js';
+import type { CSSResult, TemplateResult } from './plugins.js';
+import { sharedStyles, tableStyles } from './sw-dash-styles.js';
+
+export interface IColumnConfig {
+  key: string;
+  label: string;
+  sortable?: boolean;
+  formatter?: (value: any, row: any) => string;
+  className?: string;
+}
+
+/**
+ * Base sortable table component for sw-dash
+ */
+@customElement('sw-dash-table')
+export class SwDashTable extends LitElement {
+  public static styles: CSSResult[] = [
+    sharedStyles,
+    tableStyles,
+    css`
+      :host {
+        display: block;
+      }
+    `
+  ];
+
+  @property({ type: Array }) accessor columns: IColumnConfig[] = [];
+  @property({ type: Array }) accessor data: any[] = [];
+  @property({ type: String }) accessor filterPlaceholder = 'Filter...';
+  @property({ type: String }) accessor infoLabel = 'items';
+
+  @state() accessor sortColumn = '';
+  @state() accessor sortDirection: 'asc' | 'desc' = 'desc';
+  @state() accessor filterText = '';
+
+  // Utility formatters
+  static formatNumber(n: number): string {
+    return n.toLocaleString();
+  }
+
+  static formatBytes(bytes: number): string {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+  }
+
+  static formatTimestamp(ts: number): string {
+    if (!ts || ts === 0) return 'never';
+    const ago = Date.now() - ts;
+    if (ago < 60000) return Math.floor(ago / 1000) + 's ago';
+    if (ago < 3600000) return Math.floor(ago / 60000) + 'm ago';
+    if (ago < 86400000) return Math.floor(ago / 3600000) + 'h ago';
+    return new Date(ts).toLocaleDateString();
+  }
+
+  static getGaugeClass(rate: number): string {
+    if (rate >= 80) return 'good';
+    if (rate >= 50) return 'warning';
+    return 'bad';
+  }
+
+  private handleSort(column: string): void {
+    if (this.sortColumn === column) {
+      this.sortDirection = this.sortDirection === 'asc' ? 'desc' : 'asc';
+    } else {
+      this.sortColumn = column;
+      this.sortDirection = 'desc';
+    }
+  }
+
+  private handleFilter(e: Event): void {
+    this.filterText = (e.target as HTMLInputElement).value;
+  }
+
+  private getSortedFilteredData(): any[] {
+    let result = [...this.data];
+
+    // Filter
+    if (this.filterText) {
+      const search = this.filterText.toLowerCase();
+      result = result.filter(row => {
+        return this.columns.some(col => {
+          const val = row[col.key];
+          if (val == null) return false;
+          return String(val).toLowerCase().includes(search);
+        });
+      });
+    }
+
+    // Sort
+    if (this.sortColumn) {
+      result.sort((a, b) => {
+        let valA = a[this.sortColumn];
+        let valB = b[this.sortColumn];
+        if (typeof valA === 'string') valA = valA.toLowerCase();
+        if (typeof valB === 'string') valB = valB.toLowerCase();
+        if (valA < valB) return this.sortDirection === 'asc' ? -1 : 1;
+        if (valA > valB) return this.sortDirection === 'asc' ? 1 : -1;
+        return 0;
+      });
+    }
+
+    return result;
+  }
+
+  private renderHitRateBar(rate: number): TemplateResult {
+    const cls = SwDashTable.getGaugeClass(rate);
+    return html`
+      <span class="hit-rate-bar">
+        <span class="hit-rate-fill ${cls}" style="width: ${rate}%"></span>
+      </span>${rate}%
+    `;
+  }
+
+  protected renderCellValue(value: any, row: any, column: IColumnConfig): any {
+    if (column.formatter) {
+      return column.formatter(value, row);
+    }
+    // Special handling for hitRate
+    if (column.key === 'hitRate') {
+      return this.renderHitRateBar(value);
+    }
+    return value;
+  }
+
+  public render(): TemplateResult {
+    const sortedData = this.getSortedFilteredData();
+
+    return html`
+      <div class="table-controls">
+        <input
+          type="text"
+          class="search-input"
+          placeholder="${this.filterPlaceholder}"
+          .value="${this.filterText}"
+          @input="${this.handleFilter}"
+        >
+        <span class="table-info">${sortedData.length} of ${this.data.length} ${this.infoLabel}</span>
+      </div>
+      <div class="table-container">
+        <table class="data-table">
+          <thead>
+            <tr>
+              ${this.columns.map(col => html`
+                <th
+                  class="${this.sortColumn === col.key ? 'sorted' : ''}"
+                  @click="${() => col.sortable !== false && this.handleSort(col.key)}"
+                >
+                  ${col.label}
+                  ${col.sortable !== false ? html`
+                    <span class="sort-icon">${this.sortColumn === col.key && this.sortDirection === 'asc' ? '↑' : '↓'}</span>
+                  ` : ''}
+                </th>
+              `)}
+            </tr>
+          </thead>
+          <tbody>
+            ${sortedData.map(row => html`
+              <tr>
+                ${this.columns.map(col => html`
+                  <td class="${col.className || ''}">${this.renderCellValue(row[col.key], row, col)}</td>
+                `)}
+              </tr>
+            `)}
+          </tbody>
+        </table>
+      </div>
+    `;
+  }
+}

ts_swdash/sw-dash-types.ts

@@ -0,0 +1,52 @@
+import { LitElement, html, css, property, customElement } from './plugins.js';
+import type { CSSResult, TemplateResult } from './plugins.js';
+import { sharedStyles, tableStyles } from './sw-dash-styles.js';
+import { SwDashTable } from './sw-dash-table.js';
+import type { IColumnConfig } from './sw-dash-table.js';
+
+export interface IContentTypeStats {
+  contentType: string;
+  totalResources: number;
+  totalSize: number;
+  totalHits: number;
+  totalMisses: number;
+  hitRate: number;
+}
+
+/**
+ * Content types table view component
+ */
+@customElement('sw-dash-types')
+export class SwDashTypes extends LitElement {
+  public static styles: CSSResult[] = [
+    sharedStyles,
+    tableStyles,
+    css`
+      :host {
+        display: block;
+      }
+    `
+  ];
+
+  @property({ type: Array }) accessor contentTypes: IContentTypeStats[] = [];
+
+  private columns: IColumnConfig[] = [
+    { key: 'contentType', label: 'Content Type' },
+    { key: 'totalResources', label: 'Resources', className: 'num', formatter: SwDashTable.formatNumber },
+    { key: 'totalSize', label: 'Total Size', className: 'num', formatter: SwDashTable.formatBytes },
+    { key: 'totalHits', label: 'Hits', className: 'num', formatter: SwDashTable.formatNumber },
+    { key: 'totalMisses', label: 'Misses', className: 'num', formatter: SwDashTable.formatNumber },
+    { key: 'hitRate', label: 'Hit Rate' },
+  ];
+
+  public render(): TemplateResult {
+    return html`
+      <sw-dash-table
+        .columns="${this.columns}"
+        .data="${this.contentTypes}"
+        filterPlaceholder="Filter types..."
+        infoLabel="content types"
+      ></sw-dash-table>
+    `;
+  }
+}

ts_swdash/sw-dash-urls.ts

@@ -0,0 +1,66 @@
+import { LitElement, html, css, property, customElement } from './plugins.js';
+import type { CSSResult, TemplateResult } from './plugins.js';
+import { sharedStyles, tableStyles } from './sw-dash-styles.js';
+import { SwDashTable } from './sw-dash-table.js';
+import type { IColumnConfig } from './sw-dash-table.js';
+
+export interface ICachedResource {
+  url: string;
+  domain: string;
+  contentType: string;
+  size: number;
+  hitCount: number;
+  missCount: number;
+  lastAccessed: number;
+  cachedAt: number;
+  hitRate?: number;
+}
+
+/**
+ * URLs table view component
+ */
+@customElement('sw-dash-urls')
+export class SwDashUrls extends LitElement {
+  public static styles: CSSResult[] = [
+    sharedStyles,
+    tableStyles,
+    css`
+      :host {
+        display: block;
+      }
+    `
+  ];
+
+  @property({ type: Array }) accessor resources: ICachedResource[] = [];
+
+  private columns: IColumnConfig[] = [
+    { key: 'url', label: 'URL', className: 'url' },
+    { key: 'contentType', label: 'Type' },
+    { key: 'size', label: 'Size', className: 'num', formatter: SwDashTable.formatBytes },
+    { key: 'hitCount', label: 'Hits', className: 'num', formatter: SwDashTable.formatNumber },
+    { key: 'missCount', label: 'Misses', className: 'num', formatter: SwDashTable.formatNumber },
+    { key: 'hitRate', label: 'Hit Rate' },
+    { key: 'lastAccessed', label: 'Last Access', formatter: SwDashTable.formatTimestamp },
+  ];
+
+  private getDataWithHitRate(): ICachedResource[] {
+    return this.resources.map(r => {
+      const total = r.hitCount + r.missCount;
+      return {
+        ...r,
+        hitRate: total > 0 ? Math.round((r.hitCount / total) * 100) : 0
+      };
+    });
+  }
+
+  public render(): TemplateResult {
+    return html`
+      <sw-dash-table
+        .columns="${this.columns}"
+        .data="${this.getDataWithHitRate()}"
+        filterPlaceholder="Filter URLs..."
+        infoLabel="resources"
+      ></sw-dash-table>
+    `;
+  }
+}

ts_web_inject/index.ts

@@ -3,12 +3,15 @@ import * as interfaces from '../dist_ts_interfaces/index.js';
 import { logger } from './typedserver_web.logger.js';
 logger.log('info', `TypedServer-Devtools initialized!`);
 
-import { TypedserverInfoscreen } from './typedserver_web.infoscreen.js';
+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;
-  public infoscreen = new TypedserverInfoscreen();
+  public statusPill = new TypedserverStatusPill();
   public store = new plugins.webstore.WebStore({
     dbName: 'apiglobal__typedserver',
     storeName: 'apiglobal__typedserver',
@@ -17,14 +20,91 @@ export class ReloadChecker {
 
   public typedsocket: plugins.typedsocket.TypedSocket;
   public typedrouter = new plugins.typedrequest.TypedRouter();
+  private swStatusUnsubscribe: (() => void) | null = null;
+  private trafficLoggingEnabled = false;
 
-  constructor() {}
+  constructor() {
+    // Listen to browser online/offline events
+    window.addEventListener('online', () => {
+      this.statusPill.updateStatus({
+        source: 'network',
+        type: 'online',
+        message: 'Back online',
+        persist: false,
+        timestamp: Date.now(),
+      });
+    });
+
+    window.addEventListener('offline', () => {
+      this.statusPill.updateStatus({
+        source: 'network',
+        type: 'offline',
+        message: 'No internet connection',
+        persist: true,
+        timestamp: Date.now(),
+      });
+    });
+  }
 
   public async reload() {
     // this looks a bit hacky, but apparently is the safest way to really reload stuff
     window.location.reload();
   }
 
+  /**
+   * Subscribe to service worker status updates
+   */
+  public subscribeToServiceWorker(): void {
+    // Check if service worker client is available
+    if (globalThis.globalSw?.actionManager) {
+      this.swStatusUnsubscribe = globalThis.globalSw.actionManager.subscribeToStatusUpdates((status) => {
+        this.statusPill.updateStatus({
+          source: status.source,
+          type: status.type,
+          message: status.message,
+          details: status.details,
+          persist: status.persist || false,
+          timestamp: status.timestamp,
+        });
+      });
+      logger.log('info', 'Subscribed to service worker status updates');
+
+      // Get initial SW status
+      this.fetchServiceWorkerStatus();
+    } else {
+      logger.log('note', 'Service worker client not available yet, will retry...');
+      // Retry after a delay
+      setTimeout(() => this.subscribeToServiceWorker(), 2000);
+    }
+  }
+
+  /**
+   * Fetch and display initial service worker status
+   */
+  private async fetchServiceWorkerStatus(): Promise<void> {
+    if (!globalThis.globalSw?.actionManager) return;
+
+    try {
+      const status = await globalThis.globalSw.actionManager.getServiceWorkerStatus();
+      if (status) {
+        this.statusPill.updateStatus({
+          source: 'serviceworker',
+          type: status.isActive ? 'connected' : 'disconnected',
+          message: status.isActive ? 'Service worker active' : 'Service worker inactive',
+          details: {
+            cacheHitRate: status.cacheHitRate,
+            resourceCount: status.resourceCount,
+            connectionType: status.connectionType,
+          },
+          persist: false,
+          timestamp: Date.now(),
+        });
+      }
+    } catch (error) {
+      logger.log('warn', `Failed to get SW status: ${error}`);
+    }
+  }
+
   /**
    * starts the reload checker
    */
@@ -50,11 +130,23 @@ export class ReloadChecker {
     if (response?.status !== 200) {
       this.backendConnectionLost = true;
       logger.log('warn', `got a status ${response?.status}.`);
-      this.infoscreen.setText(`backend connection lost... Status ${response?.status}`);
+      this.statusPill.updateStatus({
+        source: 'backend',
+        type: 'disconnected',
+        message: `Backend connection lost (${response?.status || 'timeout'})`,
+        persist: true,
+        timestamp: Date.now(),
+      });
     }
     if (response?.status === 200 && this.backendConnectionLost) {
       this.backendConnectionLost = false;
-      this.infoscreen.setSuccess('regained connection to backend...');
+      this.statusPill.updateStatus({
+        source: 'backend',
+        type: 'connected',
+        message: 'Backend connection restored',
+        persist: false,
+        timestamp: Date.now(),
+      });
     }
     return response;
   }
@@ -69,10 +161,15 @@ export class ReloadChecker {
 
     if (reloadJustified) {
       this.store.set(this.storeKey, lastServerChange);
-      const reloadText = `upgrading... ${
-        globalThis.globalSw ? '(purging the sw cache first...)' : ''
-      }`;
-      this.infoscreen.setText(reloadText);
+      const hasSw = !!globalThis.globalSw;
+      this.statusPill.updateStatus({
+        source: 'serviceworker',
+        type: 'update',
+        message: hasSw ? 'Updating app...' : 'Upgrading...',
+        persist: true,
+        timestamp: Date.now(),
+      });
+
       if (globalThis.globalSw?.purgeCache) {
         await globalThis.globalSw.purgeCache();
       } else if ('caches' in window) {
@@ -87,14 +184,19 @@ export class ReloadChecker {
       } else {
         console.log('globalThis.globalSw not found and Cache API not available...');
       }
-      this.infoscreen.setText(`cleaned caches`);
+
+      this.statusPill.updateStatus({
+        source: 'serviceworker',
+        type: 'cache',
+        message: 'Cache cleared, reloading...',
+        persist: true,
+        timestamp: Date.now(),
+      });
       await plugins.smartdelay.delayFor(200);
       this.reload();
       return;
     } else {
-      if (this.infoscreen) {
-        this.infoscreen.hide();
-      }
+      // All good, hide after brief show
       return;
     }
   }
@@ -116,10 +218,22 @@ export class ReloadChecker {
         console.log(`typedsocket status: ${statusArg}`);
         if (statusArg === 'disconnected' || statusArg === 'reconnecting') {
           this.backendConnectionLost = true;
-          this.infoscreen.setText(`typedsocket ${statusArg}!`);
+          this.statusPill.updateStatus({
+            source: 'backend',
+            type: statusArg === 'disconnected' ? 'disconnected' : 'reconnecting',
+            message: `TypedSocket ${statusArg}`,
+            persist: true,
+            timestamp: Date.now(),
+          });
         } else if (statusArg === 'connected' && this.backendConnectionLost) {
           this.backendConnectionLost = false;
-          this.infoscreen.setSuccess('typedsocket connected!');
+          this.statusPill.updateStatus({
+            source: 'backend',
+            type: 'connected',
+            message: 'TypedSocket connected',
+            persist: false,
+            timestamp: Date.now(),
+          });
           // lets check if a reload is necessary
           const getLatestServerChangeTime =
             this.typedsocket.createTypedRequest<interfaces.IReq_GetLatestServerChangeTime>(
@@ -130,6 +244,9 @@ export class ReloadChecker {
         }
       });
       logger.log('success', `ReloadChecker connected through typedsocket!`);
+
+      // Enable traffic logging for sw-dash
+      this.enableTrafficLogging();
     }
   }
 
@@ -137,9 +254,13 @@ export class ReloadChecker {
   public async start() {
     this.started = true;
     logger.log('info', `starting ReloadChecker...`);
+
+    // Subscribe to service worker status updates
+    this.subscribeToServiceWorker();
+
     while (this.started) {
       const response = await this.performHttpRequest();
-      if (response.status === 200) {
+      if (response?.status === 200) {
         logger.log('info', `ReloadChecker reached backend!`);
         await this.checkReload(parseInt(await response.text()));
         await this.connectTypedsocket();
@@ -150,6 +271,55 @@ export class ReloadChecker {
 
   public async stop() {
     this.started = false;
+    if (this.swStatusUnsubscribe) {
+      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');
   }
 }
 

ts_web_inject/typedserver_web.statuspill.ts

@@ -0,0 +1,534 @@
+import { LitElement, html, css } from 'lit';
+import { customElement, property, state } from 'lit/decorators.js';
+import * as plugins from './typedserver_web.plugins.js';
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'typedserver-statuspill': TypedserverStatusPill;
+  }
+}
+
+/**
+ * Status source types
+ */
+export type TStatusSource = 'backend' | 'serviceworker' | 'network';
+
+/**
+ * Status type
+ */
+export type TStatusType = 'connected' | 'disconnected' | 'reconnecting' | 'update' | 'cache' | 'error' | 'offline' | 'online';
+
+/**
+ * Status item with details
+ */
+export interface IStatusItem {
+  source: TStatusSource;
+  type: TStatusType;
+  message: string;
+  details?: {
+    version?: string;
+    cacheHitRate?: number;
+    resourceCount?: number;
+    connectionType?: string;
+    latencyMs?: number;
+  };
+  persist: boolean;
+  timestamp: number;
+}
+
+/**
+ * Modern status pill component that displays connection and service worker status
+ * - Shows at center-bottom on connectivity changes
+ * - Stays visible during error states
+ * - Expands on hover to show detailed status
+ */
+@customElement('typedserver-statuspill')
+export class TypedserverStatusPill extends LitElement {
+  // Current status items by source
+  @state() accessor backendStatus: IStatusItem | null = null;
+  @state() accessor swStatus: IStatusItem | null = null;
+  @state() accessor networkStatus: IStatusItem | null = null;
+
+  // UI state
+  @state() accessor visible = false;
+  @state() accessor expanded = false;
+  @state() accessor hasError = false;
+
+  // Hide timeout
+  private hideTimeout: number | null = null;
+  private appended = false;
+
+  public static styles = css`
+    * {
+      box-sizing: border-box;
+    }
+
+    :host {
+      --pill-bg: rgba(20, 20, 20, 0.9);
+      --pill-bg-error: rgba(180, 40, 40, 0.95);
+      --pill-bg-success: rgba(40, 140, 60, 0.95);
+      --pill-text: #fff;
+      --pill-text-muted: rgba(255, 255, 255, 0.7);
+      --pill-border: rgba(255, 255, 255, 0.1);
+      --pill-accent: #4af;
+      --pill-success: #4f8;
+      --pill-warning: #fa4;
+      --pill-error: #f44;
+    }
+
+    .pill {
+      position: fixed;
+      bottom: 20px;
+      left: 50%;
+      transform: translateX(-50%) translateY(100px);
+      background: var(--pill-bg);
+      backdrop-filter: blur(12px);
+      -webkit-backdrop-filter: blur(12px);
+      border-radius: 24px;
+      padding: 10px 20px;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      font-size: 13px;
+      color: var(--pill-text);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 8px;
+      transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+      opacity: 0;
+      pointer-events: none;
+      z-index: 10000;
+      max-width: 90vw;
+      box-shadow: 0 4px 24px rgba(0, 0, 0, 0.3);
+      border: 1px solid var(--pill-border);
+    }
+
+    .pill.visible {
+      transform: translateX(-50%) translateY(0);
+      opacity: 1;
+      pointer-events: auto;
+    }
+
+    .pill.error {
+      background: var(--pill-bg-error);
+    }
+
+    .pill.success {
+      background: var(--pill-bg-success);
+    }
+
+    .pill-main {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      white-space: nowrap;
+    }
+
+    .status-indicator {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+
+    .status-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: var(--pill-text-muted);
+      transition: background 0.3s;
+    }
+
+    .status-dot.connected {
+      background: var(--pill-success);
+      box-shadow: 0 0 6px var(--pill-success);
+    }
+
+    .status-dot.disconnected,
+    .status-dot.offline,
+    .status-dot.error {
+      background: var(--pill-error);
+      box-shadow: 0 0 6px var(--pill-error);
+    }
+
+    .status-dot.reconnecting,
+    .status-dot.update {
+      background: var(--pill-warning);
+      animation: pulse 1s infinite;
+    }
+
+    @keyframes pulse {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.5; }
+    }
+
+    .status-label {
+      font-size: 12px;
+      font-weight: 500;
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+    }
+
+    .status-message {
+      color: var(--pill-text);
+      font-weight: 400;
+    }
+
+    .separator {
+      width: 1px;
+      height: 16px;
+      background: var(--pill-border);
+    }
+
+    .pill-expanded {
+      display: none;
+      width: 100%;
+      padding-top: 8px;
+      border-top: 1px solid var(--pill-border);
+      flex-direction: column;
+      gap: 6px;
+    }
+
+    .pill.expanded .pill-expanded {
+      display: flex;
+    }
+
+    .detail-row {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      font-size: 12px;
+      gap: 20px;
+    }
+
+    .detail-label {
+      color: var(--pill-text-muted);
+    }
+
+    .detail-value {
+      color: var(--pill-text);
+      font-weight: 500;
+    }
+
+    .detail-value.success {
+      color: var(--pill-success);
+    }
+
+    .detail-value.error {
+      color: var(--pill-error);
+    }
+
+    .detail-value.warning {
+      color: var(--pill-warning);
+    }
+
+    /* Click hint */
+    .pill::after {
+      content: '';
+      position: absolute;
+      bottom: 4px;
+      left: 50%;
+      transform: translateX(-50%);
+      width: 32px;
+      height: 3px;
+      background: var(--pill-border);
+      border-radius: 2px;
+      transition: background 0.2s;
+    }
+
+    .pill:hover::after {
+      background: var(--pill-text-muted);
+    }
+  `;
+
+  /**
+   * Update status from a specific source
+   */
+  public updateStatus(status: IStatusItem): void {
+    // Store by source
+    switch (status.source) {
+      case 'backend':
+        this.backendStatus = status;
+        break;
+      case 'serviceworker':
+        this.swStatus = status;
+        break;
+      case 'network':
+        this.networkStatus = status;
+        break;
+    }
+
+    // Determine if we have any errors (should persist)
+    this.hasError = this.hasAnyError();
+
+    // Show the pill
+    this.show();
+
+    // Auto-hide after delay if not persistent
+    if (!status.persist && !this.hasError) {
+      this.scheduleHide(2500);
+    } else {
+      this.cancelHide();
+    }
+  }
+
+  /**
+   * Check if any status is an error state
+   */
+  private hasAnyError(): boolean {
+    const errorTypes: TStatusType[] = ['disconnected', 'error', 'offline'];
+    return (
+      (this.backendStatus && errorTypes.includes(this.backendStatus.type)) ||
+      (this.networkStatus && errorTypes.includes(this.networkStatus.type)) ||
+      false
+    );
+  }
+
+  /**
+   * Get overall status class
+   */
+  private getStatusClass(): string {
+    if (this.hasError) return 'error';
+
+    const latestStatus = this.getLatestStatus();
+    if (latestStatus?.type === 'connected' || latestStatus?.type === 'online') {
+      return 'success';
+    }
+    return '';
+  }
+
+  /**
+   * Get the most recent status
+   */
+  private getLatestStatus(): IStatusItem | null {
+    const statuses = [this.backendStatus, this.swStatus, this.networkStatus].filter(Boolean) as IStatusItem[];
+    if (statuses.length === 0) return null;
+    return statuses.reduce((latest, current) =>
+      current.timestamp > latest.timestamp ? current : latest
+    );
+  }
+
+  /**
+   * Show the pill
+   */
+  public show(): void {
+    if (!this.appended) {
+      document.body.appendChild(this);
+      this.appended = true;
+    }
+    // Small delay to ensure DOM update
+    requestAnimationFrame(() => {
+      this.visible = true;
+    });
+  }
+
+  /**
+   * Hide the pill
+   */
+  public hide(): void {
+    this.visible = false;
+    this.expanded = false;
+  }
+
+  /**
+   * Schedule auto-hide
+   */
+  private scheduleHide(delayMs: number): void {
+    this.cancelHide();
+    this.hideTimeout = window.setTimeout(() => {
+      if (!this.hasError) {
+        this.hide();
+      }
+    }, delayMs);
+  }
+
+  /**
+   * Cancel scheduled hide
+   */
+  private cancelHide(): void {
+    if (this.hideTimeout) {
+      clearTimeout(this.hideTimeout);
+      this.hideTimeout = null;
+    }
+  }
+
+  /**
+   * Toggle expanded state
+   */
+  private toggleExpanded(): void {
+    this.expanded = !this.expanded;
+    if (this.expanded) {
+      this.cancelHide();
+    }
+  }
+
+  /**
+   * Clear all status and hide
+   */
+  public clearStatus(): void {
+    this.backendStatus = null;
+    this.swStatus = null;
+    this.networkStatus = null;
+    this.hasError = false;
+    this.hide();
+  }
+
+  /**
+   * Set success message (auto-hides)
+   */
+  public setSuccess(message: string, source: TStatusSource = 'backend'): void {
+    this.updateStatus({
+      source,
+      type: 'connected',
+      message,
+      persist: false,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Set error message (persists)
+   */
+  public setError(message: string, source: TStatusSource = 'backend'): void {
+    this.updateStatus({
+      source,
+      type: 'error',
+      message,
+      persist: true,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Set transitional message (auto-hides)
+   */
+  public setText(message: string, source: TStatusSource = 'backend'): void {
+    this.updateStatus({
+      source,
+      type: 'reconnecting',
+      message,
+      persist: false,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Render status indicators
+   */
+  private renderStatusIndicators() {
+    const indicators = [];
+
+    if (this.networkStatus) {
+      indicators.push(html`
+        <div class="status-indicator">
+          <span class="status-dot ${this.networkStatus.type}"></span>
+          <span class="status-label">Net</span>
+        </div>
+      `);
+    }
+
+    if (this.backendStatus) {
+      indicators.push(html`
+        <div class="status-indicator">
+          <span class="status-dot ${this.backendStatus.type}"></span>
+          <span class="status-label">API</span>
+        </div>
+      `);
+    }
+
+    if (this.swStatus) {
+      indicators.push(html`
+        <div class="status-indicator">
+          <span class="status-dot ${this.swStatus.type}"></span>
+          <span class="status-label">SW</span>
+        </div>
+      `);
+    }
+
+    return indicators;
+  }
+
+  /**
+   * Render expanded details
+   */
+  private renderDetails() {
+    const details = [];
+
+    if (this.networkStatus) {
+      details.push(html`
+        <div class="detail-row">
+          <span class="detail-label">Network</span>
+          <span class="detail-value ${this.networkStatus.type === 'online' ? 'success' : 'error'}">
+            ${this.networkStatus.message}
+            ${this.networkStatus.details?.connectionType ? ` (${this.networkStatus.details.connectionType})` : ''}
+          </span>
+        </div>
+      `);
+    }
+
+    if (this.backendStatus) {
+      details.push(html`
+        <div class="detail-row">
+          <span class="detail-label">Backend</span>
+          <span class="detail-value ${this.backendStatus.type === 'connected' ? 'success' : this.backendStatus.type === 'reconnecting' ? 'warning' : 'error'}">
+            ${this.backendStatus.message}
+          </span>
+        </div>
+      `);
+    }
+
+    if (this.swStatus) {
+      details.push(html`
+        <div class="detail-row">
+          <span class="detail-label">Service Worker</span>
+          <span class="detail-value ${this.swStatus.type === 'connected' ? 'success' : this.swStatus.type === 'update' ? 'warning' : ''}">
+            ${this.swStatus.message}
+            ${this.swStatus.details?.version ? ` v${this.swStatus.details.version}` : ''}
+          </span>
+        </div>
+      `);
+
+      if (this.swStatus.details?.cacheHitRate !== undefined) {
+        details.push(html`
+          <div class="detail-row">
+            <span class="detail-label">Cache Hit Rate</span>
+            <span class="detail-value">${this.swStatus.details.cacheHitRate.toFixed(1)}%</span>
+          </div>
+        `);
+      }
+
+      if (this.swStatus.details?.resourceCount !== undefined) {
+        details.push(html`
+          <div class="detail-row">
+            <span class="detail-label">Cached Resources</span>
+            <span class="detail-value">${this.swStatus.details.resourceCount}</span>
+          </div>
+        `);
+      }
+    }
+
+    return details;
+  }
+
+  public render() {
+    const latestStatus = this.getLatestStatus();
+    const message = latestStatus?.message || '';
+    const indicators = this.renderStatusIndicators();
+
+    return html`
+      <div
+        class="pill ${this.visible ? 'visible' : ''} ${this.getStatusClass()} ${this.expanded ? 'expanded' : ''}"
+        @click="${this.toggleExpanded}"
+      >
+        <div class="pill-main">
+          ${indicators.length > 0 ? html`
+            ${indicators}
+            ${message ? html`<span class="separator"></span>` : ''}
+          ` : ''}
+          ${message ? html`<span class="status-message">${message}</span>` : ''}
+        </div>
+        <div class="pill-expanded">
+          ${this.renderDetails()}
+        </div>
+      </div>
+    `;
+  }
+}

ts_web_serviceworker/classes.backend.ts

@@ -2,6 +2,9 @@ import * as plugins from './plugins.js';
 import * as interfaces from '../dist_ts_interfaces/index.js';
 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 {
@@ -45,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']>;
@@ -75,8 +99,228 @@ export class ServiceworkerBackend {
       return await optionsArg.purgeCache?.(reqArg);
     });
 
+    // Handler for getting current SW status
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_GetStatus>('serviceworker_getStatus', async () => {
+      const metrics = getMetricsCollector();
+      const metricsData = metrics.getMetrics();
+      return {
+        isActive: true,
+        isOnline: metricsData.speedtest.isOnline,
+        cacheHitRate: metrics.getCacheHitRate(),
+        resourceCount: metrics.getResourceCount(),
+        connectedClients: metricsData.connection.connectedClients,
+        lastUpdateCheck: metricsData.update.lastCheckTimestamp,
+      };
+    });
+
+    // Handler for getting event log
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_GetEventLog>('serviceworker_getEventLog', async (reqArg) => {
+      const persistentStore = getPersistentStore();
+      return await persistentStore.getEventLog({
+        limit: reqArg.limit,
+        type: reqArg.type,
+        since: reqArg.since,
+        before: reqArg.before,
+      });
+    });
+
+    // Handler for getting cumulative metrics
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_GetCumulativeMetrics>('serviceworker_getCumulativeMetrics', async () => {
+      const persistentStore = getPersistentStore();
+      return persistentStore.getCumulativeMetrics();
+    });
+
+    // Handler for clearing event log
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_ClearEventLog>('serviceworker_clearEventLog', async () => {
+      const persistentStore = getPersistentStore();
+      const success = await persistentStore.clearEventLog();
+      return { success };
+    });
+
+    // Handler for getting event count since timestamp
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_GetEventCount>('serviceworker_getEventCount', async (reqArg) => {
+      const persistentStore = getPersistentStore();
+      const count = await persistentStore.getEventCount(reqArg.since);
+      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();
+
+    // Subscribe to EventBus and broadcast status updates
+    this.setupEventBusSubscriptions();
+  }
+
+  /**
+   * Sets up subscriptions to EventBus events and broadcasts them to clients
+   */
+  private setupEventBusSubscriptions(): void {
+    const eventBus = getEventBus();
+    const persistentStore = getPersistentStore();
+
+    // Network status changes
+    eventBus.on(ServiceWorkerEvent.NETWORK_ONLINE, async () => {
+      this.broadcastStatusUpdate({
+        source: 'network',
+        type: 'online',
+        message: 'Connection restored',
+        persist: false,
+        timestamp: Date.now(),
+      });
+      // Log to persistent store
+      await persistentStore.logEvent('network_online', 'Network connection restored');
+    });
+
+    eventBus.on(ServiceWorkerEvent.NETWORK_OFFLINE, async () => {
+      this.broadcastStatusUpdate({
+        source: 'network',
+        type: 'offline',
+        message: 'Connection lost - offline mode',
+        persist: true,
+        timestamp: Date.now(),
+      });
+      // Log to persistent store
+      await persistentStore.logEvent('network_offline', 'Network connection lost');
+    });
+
+    // Update events
+    eventBus.on(ServiceWorkerEvent.UPDATE_AVAILABLE, async (_event, payload: any) => {
+      this.broadcastStatusUpdate({
+        source: 'serviceworker',
+        type: 'update',
+        message: 'Update available',
+        details: {
+          version: payload.newVersion,
+        },
+        persist: false,
+        timestamp: Date.now(),
+      });
+      // Log to persistent store
+      await persistentStore.logEvent('update_check', `Update available: ${payload.newVersion}`, {
+        newVersion: payload.newVersion,
+      });
+    });
+
+    eventBus.on(ServiceWorkerEvent.UPDATE_APPLIED, async (_event, payload: any) => {
+      this.broadcastStatusUpdate({
+        source: 'serviceworker',
+        type: 'update',
+        message: 'Update applied',
+        details: {
+          version: payload.newVersion,
+        },
+        persist: false,
+        timestamp: Date.now(),
+      });
+      // Log to persistent store
+      await persistentStore.logEvent('sw_updated', `Service worker updated to ${payload.newVersion}`, {
+        newVersion: payload.newVersion,
+      });
+    });
+
+    eventBus.on(ServiceWorkerEvent.UPDATE_ERROR, async (_event, payload: any) => {
+      this.broadcastStatusUpdate({
+        source: 'serviceworker',
+        type: 'error',
+        message: `Update error: ${payload.error || 'Unknown error'}`,
+        persist: true,
+        timestamp: Date.now(),
+      });
+      // Log to persistent store
+      await persistentStore.logEvent('error', `Update error: ${payload.error || 'Unknown error'}`, {
+        error: payload.error,
+      });
+    });
+
+    // Cache invalidation
+    eventBus.on(ServiceWorkerEvent.CACHE_INVALIDATE_ALL, () => {
+      this.broadcastStatusUpdate({
+        source: 'serviceworker',
+        type: 'cache',
+        message: 'Clearing cache...',
+        persist: false,
+        timestamp: Date.now(),
+      });
+      // Note: cache_invalidated event is logged in the ServiceWorker class
+    });
+
+    // Lifecycle events
+    eventBus.on(ServiceWorkerEvent.ACTIVATE, () => {
+      this.broadcastStatusUpdate({
+        source: 'serviceworker',
+        type: 'connected',
+        message: 'Service worker activated',
+        persist: false,
+        timestamp: Date.now(),
+      });
+      // Note: sw_activated event is logged in the ServiceWorker class
+    });
+  }
+
+  /**
+   * Broadcasts a status update to all connected clients
+   */
+  public async broadcastStatusUpdate(status: interfaces.serviceworker.IStatusUpdate): Promise<void> {
+    try {
+      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}`);
+    }
   }
 
   /**
@@ -114,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' });
@@ -181,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}`);
+    }
+  }
 }

ts_web_serviceworker/classes.cachemanager.ts

@@ -210,16 +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;
+        }
+        // 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 (
@@ -260,7 +271,9 @@ export class CacheManager {
             // Record cache hit
             const contentLength = cachedResponse.headers.get('content-length');
             const bytes = contentLength ? parseInt(contentLength, 10) : 0;
+            const contentType = cachedResponse.headers.get('content-type') || 'unknown';
             metrics.recordCacheHit(matchRequest.url, bytes);
+            metrics.recordResourceAccess(matchRequest.url, true, contentType, bytes);
             eventBus.emitCacheHit(matchRequest.url, bytes);
 
             logger.log('ok', `CACHED: Found cached response for ${matchRequest.url}`);
@@ -335,6 +348,12 @@ export class CacheManager {
               });
 
               await cache.put(matchRequest, newCachedResponse);
+
+              // Record resource access for per-resource tracking
+              const cachedContentType = newResponse.headers.get('content-type') || 'unknown';
+              const cachedSize = bodyBlob.size;
+              metrics.recordResourceAccess(matchRequest.url, false, cachedContentType, cachedSize);
+
               logger.log('ok', `NOWCACHED: Cached response for ${matchRequest.url} for subsequent requests!`);
               done.resolve(newResponse);
             } catch (err) {

ts_web_serviceworker/classes.metrics.ts

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

ts_web_serviceworker/classes.persistentstore.ts

@@ -0,0 +1,424 @@
+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;
+type TEventType = serviceworker.TEventType;
+
+/**
+ * Generates a simple UUID
+ */
+function generateId(): string {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+
+/**
+ * Default cumulative metrics
+ */
+function createDefaultMetrics(): ICumulativeMetrics {
+  return {
+    firstSeenTimestamp: Date.now(),
+    totalCacheHits: 0,
+    totalCacheMisses: 0,
+    totalCacheErrors: 0,
+    totalBytesServedFromCache: 0,
+    totalBytesFetched: 0,
+    totalNetworkRequests: 0,
+    totalNetworkSuccesses: 0,
+    totalNetworkFailures: 0,
+    totalNetworkTimeouts: 0,
+    totalBytesTransferred: 0,
+    totalUpdateChecks: 0,
+    totalUpdatesApplied: 0,
+    totalSpeedtests: 0,
+    swRestartCount: 0,
+    lastUpdatedTimestamp: Date.now(),
+  };
+}
+
+/**
+ * PersistentStore manages persistent data for the service worker:
+ * - Cumulative metrics: Persist across SW restarts, reset on cache invalidation
+ * - Event log: Persists across SW restarts AND cache invalidation
+ */
+export class PersistentStore {
+  private static instance: PersistentStore;
+  private store: plugins.webstore.WebStore;
+  private initialized = false;
+
+  // Storage keys
+  private readonly CUMULATIVE_KEY = 'metrics_cumulative';
+  private readonly EVENT_LOG_KEY = 'event_log';
+
+  // Retention settings
+  private readonly MAX_EVENTS = 10000;
+  private readonly MAX_AGE_DAYS = 30;
+  private readonly MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days in ms
+
+  // Save interval (60 seconds)
+  private readonly SAVE_INTERVAL_MS = 60000;
+  private saveInterval: ReturnType<typeof setInterval> | null = null;
+
+  // In-memory cache for cumulative metrics
+  private cumulativeMetrics: ICumulativeMetrics | null = null;
+  private isDirty = false;
+
+  private constructor() {
+    this.store = new plugins.webstore.WebStore({
+      dbName: 'losslessServiceworkerPersistent',
+      storeName: 'persistentStore',
+    });
+  }
+
+  /**
+   * Gets the singleton instance
+   */
+  public static getInstance(): PersistentStore {
+    if (!PersistentStore.instance) {
+      PersistentStore.instance = new PersistentStore();
+    }
+    return PersistentStore.instance;
+  }
+
+  /**
+   * Initializes the store and starts periodic saving
+   */
+  public async init(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    try {
+      // Initialize the WebStore (required before using any methods)
+      await this.store.init();
+      await this.loadCumulativeMetrics();
+
+      // Increment restart count
+      if (this.cumulativeMetrics) {
+        this.cumulativeMetrics.swRestartCount++;
+        this.isDirty = true;
+        await this.saveCumulativeMetrics();
+      }
+
+      // Start periodic save
+      this.startPeriodicSave();
+
+      this.initialized = true;
+      logger.log('ok', '[PersistentStore] Initialized successfully');
+    } catch (error) {
+      logger.log('error', `[PersistentStore] Failed to initialize: ${error}`);
+      // Don't throw - allow SW to continue even if persistent store fails
+      this.initialized = true; // Mark as initialized to prevent retry loops
+    }
+  }
+
+  /**
+   * Starts periodic saving of metrics
+   */
+  private startPeriodicSave(): void {
+    if (this.saveInterval) {
+      clearInterval(this.saveInterval);
+    }
+
+    this.saveInterval = setInterval(async () => {
+      if (this.isDirty) {
+        await this.saveCumulativeMetrics();
+      }
+    }, this.SAVE_INTERVAL_MS);
+  }
+
+  /**
+   * Stops periodic saving
+   */
+  public stopPeriodicSave(): void {
+    if (this.saveInterval) {
+      clearInterval(this.saveInterval);
+      this.saveInterval = null;
+    }
+  }
+
+  // ===================
+  // Cumulative Metrics
+  // ===================
+
+  /**
+   * Loads cumulative metrics from store
+   */
+  public async loadCumulativeMetrics(): Promise<ICumulativeMetrics> {
+    try {
+      if (await this.store.check(this.CUMULATIVE_KEY)) {
+        this.cumulativeMetrics = await this.store.get(this.CUMULATIVE_KEY);
+      } else {
+        this.cumulativeMetrics = createDefaultMetrics();
+        this.isDirty = true;
+      }
+    } catch (error) {
+      logger.log('warn', `[PersistentStore] Failed to load metrics: ${error}`);
+      this.cumulativeMetrics = createDefaultMetrics();
+      this.isDirty = true;
+    }
+
+    return this.cumulativeMetrics!;
+  }
+
+  /**
+   * Saves cumulative metrics to store
+   */
+  public async saveCumulativeMetrics(): Promise<void> {
+    if (!this.cumulativeMetrics) {
+      return;
+    }
+
+    try {
+      this.cumulativeMetrics.lastUpdatedTimestamp = Date.now();
+      await this.store.set(this.CUMULATIVE_KEY, this.cumulativeMetrics);
+      this.isDirty = false;
+      logger.log('note', '[PersistentStore] Cumulative metrics saved');
+    } catch (error) {
+      logger.log('error', `[PersistentStore] Failed to save metrics: ${error}`);
+    }
+  }
+
+  /**
+   * Gets the current cumulative metrics
+   */
+  public getCumulativeMetrics(): ICumulativeMetrics {
+    if (!this.cumulativeMetrics) {
+      return createDefaultMetrics();
+    }
+    return { ...this.cumulativeMetrics };
+  }
+
+  /**
+   * Updates cumulative metrics with session delta
+   */
+  public updateCumulativeMetrics(delta: Partial<ICumulativeMetrics>): void {
+    if (!this.cumulativeMetrics) {
+      this.cumulativeMetrics = createDefaultMetrics();
+    }
+
+    // Add delta values to cumulative
+    if (delta.totalCacheHits !== undefined) {
+      this.cumulativeMetrics.totalCacheHits += delta.totalCacheHits;
+    }
+    if (delta.totalCacheMisses !== undefined) {
+      this.cumulativeMetrics.totalCacheMisses += delta.totalCacheMisses;
+    }
+    if (delta.totalCacheErrors !== undefined) {
+      this.cumulativeMetrics.totalCacheErrors += delta.totalCacheErrors;
+    }
+    if (delta.totalBytesServedFromCache !== undefined) {
+      this.cumulativeMetrics.totalBytesServedFromCache += delta.totalBytesServedFromCache;
+    }
+    if (delta.totalBytesFetched !== undefined) {
+      this.cumulativeMetrics.totalBytesFetched += delta.totalBytesFetched;
+    }
+    if (delta.totalNetworkRequests !== undefined) {
+      this.cumulativeMetrics.totalNetworkRequests += delta.totalNetworkRequests;
+    }
+    if (delta.totalNetworkSuccesses !== undefined) {
+      this.cumulativeMetrics.totalNetworkSuccesses += delta.totalNetworkSuccesses;
+    }
+    if (delta.totalNetworkFailures !== undefined) {
+      this.cumulativeMetrics.totalNetworkFailures += delta.totalNetworkFailures;
+    }
+    if (delta.totalNetworkTimeouts !== undefined) {
+      this.cumulativeMetrics.totalNetworkTimeouts += delta.totalNetworkTimeouts;
+    }
+    if (delta.totalBytesTransferred !== undefined) {
+      this.cumulativeMetrics.totalBytesTransferred += delta.totalBytesTransferred;
+    }
+    if (delta.totalUpdateChecks !== undefined) {
+      this.cumulativeMetrics.totalUpdateChecks += delta.totalUpdateChecks;
+    }
+    if (delta.totalUpdatesApplied !== undefined) {
+      this.cumulativeMetrics.totalUpdatesApplied += delta.totalUpdatesApplied;
+    }
+    if (delta.totalSpeedtests !== undefined) {
+      this.cumulativeMetrics.totalSpeedtests += delta.totalSpeedtests;
+    }
+
+    this.isDirty = true;
+  }
+
+  /**
+   * Resets cumulative metrics (called on cache invalidation)
+   */
+  public async resetCumulativeMetrics(): Promise<void> {
+    this.cumulativeMetrics = createDefaultMetrics();
+    this.isDirty = true;
+    await this.saveCumulativeMetrics();
+    logger.log('info', '[PersistentStore] Cumulative metrics reset');
+  }
+
+  // ===================
+  // Event Log
+  // ===================
+
+  /**
+   * Logs an event to the persistent event log
+   */
+  public async logEvent(
+    type: TEventType,
+    message: string,
+    details?: Record<string, any>
+  ): Promise<void> {
+    const entry: IEventLogEntry = {
+      id: generateId(),
+      timestamp: Date.now(),
+      type,
+      message,
+      details,
+    };
+
+    try {
+      // Ensure initialized
+      if (!this.initialized) {
+        await this.init();
+      }
+
+      let events: IEventLogEntry[] = [];
+
+      if (await this.store.check(this.EVENT_LOG_KEY)) {
+        events = await this.store.get(this.EVENT_LOG_KEY);
+      }
+
+      // Add new entry
+      events.push(entry);
+
+      // Apply retention policy
+      events = this.applyRetentionPolicy(events);
+
+      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}`);
+    }
+  }
+
+  /**
+   * Gets event log entries
+   */
+  public async getEventLog(options?: {
+    limit?: number;
+    type?: TEventType;
+    since?: number;
+    before?: number;
+  }): Promise<{ events: IEventLogEntry[]; totalCount: number }> {
+    try {
+      let events: IEventLogEntry[] = [];
+
+      if (await this.store.check(this.EVENT_LOG_KEY)) {
+        events = await this.store.get(this.EVENT_LOG_KEY);
+      }
+
+      const totalCount = events.length;
+
+      // Filter by type if specified
+      if (options?.type) {
+        events = events.filter(e => e.type === options.type);
+      }
+
+      // Filter by since timestamp if specified
+      if (options?.since) {
+        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);
+
+      // Apply limit if specified
+      if (options?.limit && options.limit > 0) {
+        events = events.slice(0, options.limit);
+      }
+
+      return { events, totalCount };
+    } catch (error) {
+      logger.log('error', `[PersistentStore] Failed to get event log: ${error}`);
+      return { events: [], totalCount: 0 };
+    }
+  }
+
+  /**
+   * Gets count of events since a timestamp
+   */
+  public async getEventCount(since: number): Promise<number> {
+    try {
+      if (!(await this.store.check(this.EVENT_LOG_KEY))) {
+        return 0;
+      }
+
+      const events: IEventLogEntry[] = await this.store.get(this.EVENT_LOG_KEY);
+      return events.filter(e => e.timestamp >= since).length;
+    } catch (error) {
+      logger.log('error', `[PersistentStore] Failed to get event count: ${error}`);
+      return 0;
+    }
+  }
+
+  /**
+   * Clears all events from the log
+   */
+  public async clearEventLog(): Promise<boolean> {
+    try {
+      await this.store.set(this.EVENT_LOG_KEY, []);
+      logger.log('info', '[PersistentStore] Event log cleared');
+      return true;
+    } catch (error) {
+      logger.log('error', `[PersistentStore] Failed to clear event log: ${error}`);
+      return false;
+    }
+  }
+
+  /**
+   * Applies retention policy to event log:
+   * - Max 10,000 events
+   * - Max 30 days old
+   */
+  private applyRetentionPolicy(events: IEventLogEntry[]): IEventLogEntry[] {
+    const now = Date.now();
+    const cutoffTime = now - this.MAX_AGE_MS;
+
+    // Filter out events older than 30 days
+    let filtered = events.filter(e => e.timestamp >= cutoffTime);
+
+    // If still over limit, remove oldest entries
+    if (filtered.length > this.MAX_EVENTS) {
+      // Sort by timestamp (oldest first) then keep only newest MAX_EVENTS
+      filtered.sort((a, b) => a.timestamp - b.timestamp);
+      filtered = filtered.slice(filtered.length - this.MAX_EVENTS);
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Flushes pending changes (call before SW stops)
+   */
+  public async flush(): Promise<void> {
+    if (this.isDirty && this.cumulativeMetrics) {
+      await this.saveCumulativeMetrics();
+    }
+  }
+}
+
+// Export singleton getter for convenience
+export const getPersistentStore = (): PersistentStore => PersistentStore.getInstance();

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

ts_web_serviceworker/classes.serviceworker.ts

@@ -12,6 +12,7 @@ import { UpdateManager } from './classes.updatemanager.js';
 import { NetworkManager } from './classes.networkmanager.js';
 import { TaskManager } from './classes.taskmanager.js';
 import { ServiceworkerBackend } from './classes.backend.js';
+import { getPersistentStore } from './classes.persistentstore.js';
 
 export class ServiceWorker {
   // STATIC
@@ -63,6 +64,14 @@ export class ServiceWorker {
       // its important to not go async before event.waitUntil
       try {
         logger.log('success', `service worker installed! TimeStamp = ${new Date().toISOString()}`);
+
+        // Log installation event
+        const persistentStore = getPersistentStore();
+        await persistentStore.init();
+        await persistentStore.logEvent('sw_installed', 'Service worker installed', {
+          timestamp: new Date().toISOString(),
+        });
+
         selfArg.skipWaiting();
         logger.log('note', `Called skip waiting!`);
         done.resolve();
@@ -84,6 +93,13 @@ export class ServiceWorker {
         await this.cacheManager.cleanCaches('new service worker loaded! :)');
         logger.log('ok', 'Caches cleaned successfully');
 
+        // 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(),
+        });
+
         done.resolve();
         logger.log('success', `Service worker activated at ${new Date().toISOString()}`);
 
@@ -94,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();
+    }
   }
 
   /**
@@ -105,6 +128,18 @@ export class ServiceWorker {
       this.typedrouter.addTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_CacheInvalidate>(
         new plugins.typedrequest.TypedHandler('serviceworker_cacheInvalidate', async (reqArg) => {
           logger.log('info', `Cache invalidation requested from server: ${reqArg.reason}`);
+
+          // 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,
+          });
+
+          // Reset cumulative metrics (they don't survive cache invalidation)
+          await persistentStore.resetCumulativeMetrics();
+
           await this.cacheManager.cleanCaches(reqArg.reason);
           // Notify all clients to reload
           await this.leleServiceWorkerBackend.triggerReloadAll();

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;

ts_web_serviceworker/index.ts

@@ -1,10 +1,4 @@
-// TypeScript declatations
-import * as env from './env.js';
-declare var self: env.ServiceWindow;
-
-import { ServiceWorker } from './classes.serviceworker.js';
-
-const sw = new ServiceWorker(self);
-
-// Export getter for service worker instance (used by dashboard for TypedSocket access)
-export const getServiceWorkerInstance = (): ServiceWorker => sw;
+// Service worker entry point - NO EXPORTS here!
+// Exports at entry point cause tsbundle to output ESM format which service workers can't use.
+// The actual initialization happens in init.ts which other modules can import from.
+import './init.js';

ts_web_serviceworker/init.ts

@@ -0,0 +1,13 @@
+// Service worker initialization - creates and exports the SW instance
+// Other modules in the bundle can import from here
+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;

ts_web_serviceworker_client/classes.actionmanager.ts

@@ -26,8 +26,14 @@ const DEFAULT_CONNECTION_OPTIONS: IConnectionOptions = {
  * * the serviceWorker method
  * * the deesComms method using BroadcastChannel
  */
+/**
+ * Callback type for status update subscriptions
+ */
+export type TStatusUpdateCallback = (status: interfaces.serviceworker.IStatusUpdate) => void;
+
 export class ActionManager {
   public deesComms = new plugins.deesComms.DeesComms();
+  private statusCallbacks: Set<TStatusUpdateCallback> = new Set();
 
   constructor() {
     // lets define handlers on the client/tab side
@@ -37,6 +43,49 @@ export class ActionManager {
       }, 200);
       return {};
     });
+
+    // Handler for status updates from service worker
+    this.deesComms.createTypedHandler<interfaces.serviceworker.IMessage_Serviceworker_StatusUpdate>('serviceworker_statusUpdate', async (status) => {
+      // Forward to all registered callbacks
+      for (const callback of this.statusCallbacks) {
+        try {
+          callback(status);
+        } catch (error) {
+          logger.log('warn', `Status callback error: ${error}`);
+        }
+      }
+      return {};
+    });
+  }
+
+  /**
+   * Subscribe to status updates from the service worker
+   * @returns Unsubscribe function
+   */
+  public subscribeToStatusUpdates(callback: TStatusUpdateCallback): () => void {
+    this.statusCallbacks.add(callback);
+    logger.log('info', 'Subscribed to service worker status updates');
+    return () => {
+      this.statusCallbacks.delete(callback);
+      logger.log('info', 'Unsubscribed from service worker status updates');
+    };
+  }
+
+  /**
+   * Get current service worker status
+   */
+  public async getServiceWorkerStatus(): Promise<interfaces.serviceworker.IRequest_Serviceworker_GetStatus['response'] | null> {
+    try {
+      const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Serviceworker_GetStatus>('serviceworker_getStatus');
+      const response = await Promise.race([
+        tr.fire({}),
+        new Promise<null>((resolve) => setTimeout(() => resolve(null), 5000)),
+      ]);
+      return response;
+    } catch (error) {
+      logger.log('warn', `Failed to get service worker status: ${error}`);
+      return null;
+    }
   }
 
   /**
@@ -142,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)');
+    };
+  }
 }