7.8.8

chore: update @api.global/typedrequest to version 3.2.1
7.8.7
2025-12-04 22:20:55 +00:00 · 2025-12-04 22:20:44 +00:00 · 2025-12-04 21:54:08 +00:00 · 2025-12-04 21:53:45 +00:00 · 2025-12-04 21:40:08 +00:00 · 2025-12-04 21:40:05 +00:00
69 changed files with 13705 additions and 6000 deletions
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,346 @@
 # 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
+
+- Add `serviceworker_speedtest` typed handler in TypedServer to support download/upload/latency tests from service workers
+- Export `getServiceWorkerInstance` from the web_serviceworker entrypoint so other modules (dashboard) can access the running ServiceWorker instance
+- Make ServiceWorker.typedsocket and ServiceWorker.typedrouter public to allow the dashboard to create and fire TypedSocket requests
+- Update dashboard to run latency, download and upload tests over TypedSocket instead of POSTing to /sw-typedrequest
+- Deprecate legacy servertools.Server.addTypedSocket (now a no-op) and recommend using TypedServer with SmartServe integration for WebSocket support
+
+## 2025-12-04 - 6.5.0 - feat(serviceworker)
+Add server-driven service worker cache invalidation and TypedSocket integration
+
+- TypedServer: push cache invalidation messages to service worker clients (tagged 'serviceworker') before notifying frontend clients on reload
+- Service Worker: connect to TypedServer via TypedSocket; handle 'serviceworker_cacheInvalidate' typed request to clean caches and trigger client reloads
+- Web inject: add fallback to clear caches via the Cache API when global service worker helper is not available
+- Interfaces: add IRequest_Serviceworker_CacheInvalidate typedrequest interface
+- Plugins: export typedsocket in web_serviceworker plugin surface
+- Service worker connection: retry logic and improved logging for TypedSocket connection attempts
+
+## 2025-12-04 - 6.4.0 - feat(serviceworker)
+Add speedtest support to service worker and dashboard
+
+- Add serviceworker_speedtest typed request handler to measure download, upload and latency
+- Expose dashboard speedtest endpoint (/sw-dash/speedtest) and integrate runSpeedtest flow
+- Dashboard UI: add speedtest panel, run button, visual speed bars and online indicator
+- Metrics: introduce ISpeedtestMetrics and methods (recordSpeedtest, setOnlineStatus, getSpeedtestMetrics) and include speedtest data in metrics output
+- Server/tools: add typedrequest handling for speedtest in sw-typedrequest and route service worker dashboard path in CacheManager
+
+## 2025-12-04 - 6.3.0 - feat(web_serviceworker)
+Add advanced service worker subsystems: cache deduplication, metrics, update & network managers, event bus and dashboard
+
+- CacheManager: request deduplication for concurrent fetches, safer caching (preserve CORS headers), periodic in-flight cleanup and full cache cleaning API
+- Fetch handling: improved handling for same-origin vs cross-origin requests, more robust 500 debug responses when upstream fetch fails
+- UpdateManager: rate-limited update checks, offline grace period, debounced update and cache revalidation tasks, forceUpdate logic and persisted version/cache timestamps
+- NetworkManager: online/offline detection, retry/backoff, request timeouts and more resilient makeRequest implementation
+- EventBus: singleton pub/sub with history, once/onMany/onAll helpers and convenience emitters for cache/network/update events
+- MetricsCollector: comprehensive metrics for cache, network, updates and connections with helper methods and JSON/HTML dashboard endpoints (/sw-dash, /sw-dash/metrics)
+- ErrorHandler & ServiceWorkerError: structured error types, severity, context, history and helper APIs for consistent error reporting
+- ServiceWorker & backend: improved install/activate flows, clients.claim(), cache cleaning on activation, backend APIs to purge cache and trigger reloads/notifications
+- TypedServer / servertools: addRoute path pattern parsing (named params & wildcards), safer HTML injection for reload script, TypedRequest controller and service worker route helpers
+- Various safety and compatibility improvements (response cloning, header normalization, cache-control decisions, and fallback behaviors)
+
+## 2025-12-04 - 6.2.0 - feat(web_serviceworker)
+Add service-worker dashboard and request deduplication; improve caching, metrics and error handling
+
+- Add DashboardGenerator to serve an interactive terminal-style dashboard at /sw-dash and a metrics JSON endpoint at /sw-dash/metrics
+- Introduce request deduplication in CacheManager to coalesce concurrent network fetches and avoid duplicate requests
+- Add periodic cleanup for in-flight request tracking to prevent unbounded memory growth
+- Improve caching flow: preserve response headers (excluding cache-control headers), ensure CORS headers and Cross-Origin-Resource-Policy, and store response bodies as blobs to avoid locked stream issues
+- Provide clearer 500 error HTML responses for failed fetches to aid debugging
+- Integrate metrics and event emissions for network and cache operations (record request success/failure, cache hits/misses, and emit corresponding events)
+
+## 2025-12-04 - 6.1.0 - feat(web_serviceworker)
+Enhance service worker subsystem: add metrics, event bus, error handling, config and caching/update improvements; make client connection & polling robust
+
+- Introduce MetricsCollector (cache, network, update, connection) for runtime observability and APIs to retrieve metrics
+- Add EventBus singleton to emit/subscribe to internal SW events (cache hits/misses, network events, update lifecycle, connection events)
+- Add ErrorHandler and ServiceWorkerError types for consistent error classification and tracking
+- Add ServiceWorkerConfig with defaults and WebStore persistence to centralize SW settings (cache, update, network, blocked/cacheable domains)
+- CacheManager: implement request deduplication (in-flight request coalescing), periodic in-flight cleanup, record cache hit/miss metrics and safer cache storing (headers/body handling)
+- UpdateManager: rate-limited and concurrency-safe update checks, improved stale-cache handling, event emissions, debounced update and revalidation tasks, and metrics recording
+- NetworkManager: enhanced online/offline detection and robust request retries/timeouts/backoff handling
+- ServiceworkerBackend: improved client reload logic and notification handling via DeesComms and clients API
+- Serviceworker client-side: ActionManager.waitForServiceWorkerConnection now returns a structured result with timeout/retries/backoff; ServiceworkerClient gains controllable polling (AbortController), visibility-based pause/resume, manual trigger and lifecycle cleanup
+- Expose serviceworker bundle routes at both nested and root paths (/serviceworker/*splat and /serviceworker.bundle.js(.map)) in servertools
+- Add/extend typed interfaces for serviceworker metrics and connection results
+
+## 2025-12-04 - 6.0.1 - fix(web_inject)
+Use TypedSocket status API in web_inject and bump dependencies
+
+- ts_web_inject: switch from typedsocket.addTag + eventSubject to await typedsocket.setTag + statusSubject; update logging and handle 'reconnecting' status as backend connection loss
+- Await setTag call to ensure tag is applied before relying on socket state
+- Bump dependencies: @api.global/typedrequest -> ^3.1.11, @api.global/typedsocket -> ^4.1.0, @push.rocks/smartserve -> ^1.1.2
+
+## 2025-12-03 - 6.0.0 - BREAKING CHANGE(servertools.Server.addTypedSocket)
+Deprecate Server.addTypedSocket and upgrade typedsocket to v4; make addTypedSocket a no-op and log a deprecation warning. Bump tsbundle devDependency.
+
+- Upgrade dependency @api.global/typedsocket to ^4.0.0. TypedSocket v4 no longer supports attaching to an existing Express server.
+- Deprecate servertools.Server.addTypedSocket(): the method is now a no-op and emits a console.warn directing users to use TypedServer with SmartServe integration for WebSocket support.
+- Bump devDependency @git.zone/tsbundle to ^2.6.3.
+- Breaking change: any consumer code that relied on addTypedSocket to attach a WebSocket server to an existing Express instance will need to migrate to the new SmartServe/TypedServer integration.
+
+## 2025-12-02 - 5.0.0 - BREAKING CHANGE(devtools)
+Switch /reloadcheck endpoint from GET to POST in DevToolsController
+
+- Updated ts/controllers/controller.devtools.ts: decorator changed from @plugins.smartserve.Get('/reloadcheck') to @plugins.smartserve.Post('/reloadcheck').
+- Clients that previously performed GET requests against /reloadcheck must be updated to use POST. This is a breaking API change.
+- Bump major version to reflect the change in the public HTTP API.
+
+## 2025-12-02 - 4.1.1 - fix(classes.typedserver)
+Instantiate and register DevToolsController only when injectReload is enabled; compile ControllerRegistry routes after registration
+
+- DevToolsController is now created and registered only if options.injectReload is true to avoid unnecessary/invalid registrations when live reload is disabled.
+- ControllerRegistry.compileRoutes() is invoked after registering controllers to precompile decorated routes for faster route matching.
+
+## 2025-12-02 - 4.1.0 - feat(TypedServer)
+Integrate SmartServe controller routing; add built-in routes controller and refactor TypedServer to use controllers and FileServer
+
+- Add BuiltInRoutesController exposing /robots.txt, /manifest.json, /sitemap, /sitemap-news, /feed and /appversion
+- Refactor TypedRequestHandler into a SmartServe-decorated TypedRequestController and register it with ControllerRegistry
+- Refactor TypedServer to use SmartServe: register controller instances, use ControllerRegistry matching, and delegate WebSocket integration to SmartServe
+- Introduce FileServer-based static serving with HTML reload script injection and improved default root handling
+- Expand supported HTTP methods to include HEAD and OPTIONS
+- Remove legacy FeedHelper and consolidate sitemap/feed handling into controllers and helpers
+- Enhance servertools legacy Express utilities: improved HandlerProxy, HandlerStatic, Compressor with caching and preferred compression support
+- Service worker subsystem improvements: CacheManager, NetworkManager, UpdateManager and backend enhancements for robust caching, revalidation and client reloads
+- Web-inject LitElement properties switched from private fields to accessor syntax (typedserver_web.infoscreen)
+
+## 2025-12-02 - 4.0.0 - BREAKING CHANGE(typedserver)
+Migrate to new push.rocks packages and async smartfs API; replace smartchok with smartwatch; update deps and service worker handling
+
+- Major dependency updates: @push.rocks packages upgraded (smartfile -> v13, smartfs added v1.2.0, smartenv v6, smartrequest v5, smartwatch v5, webrequest v4), Express and dev-tooling bumped.
+- Replace sync smartfile APIs with async SmartFs instance (plugins.fsInstance). All file reads now use async smartfs calls.
+- smartfile v13 migration: removed sync fs helpers; added plugins.fsInstance (SmartFs + Node provider).
+- Renamed file watcher usage: Smartchok -> Smartwatch and property names updated (smartwatchInstance).
+- WebRequest class rename handled: WebRequest -> WebrequestClient (webrequest v4).
+- Service worker bundle is lazy-loaded (avoid startup sync file reads) and added routes for bundle and source map.
+- Service worker & SW-related improvements: more robust caching, enhanced cache headers, offline handling, revalidation, and update forcing logic.
+- createServeDirHash now uses smartfs.directory().recursive().treeHash() and truncates hash to 12 chars; fallback hash logic retained.
+- HandlerStatic, HandlerProxy and route handling hardened for Express 5 wildcard params (array/various shapes supported).
+- Various runtime improvements: safer start/stop handling, improved error logging, and non-blocking initialization of optional features (file watcher, TypedSocket).
+- Updated tooling/dev deps: @git.zone/tsbuild/tsbundle/tstest and @types/node updated.
+
+## 2025-11-19 - 3.0.80 - fix(dependencies)
+Bump dependencies and devDependencies to updated versions
+
+- Upgrade @push.rocks/smartfeed: ^1.0.11 → ^1.4.0
+- Upgrade @push.rocks/smartfile: ^11.2.5 → ^11.2.7
+- Upgrade @push.rocks/smartjson: ^5.0.20 → ^5.2.0
+- Upgrade @push.rocks/smartlog: ^3.1.8 → ^3.1.10
+- Upgrade @push.rocks/smartsitemap: ^2.0.3 → ^2.0.4
+- Upgrade @push.rocks/taskbuffer: ^3.1.7 → ^3.4.0
+- Upgrade @tsclass/tsclass: ^9.2.0 → ^9.3.0
+- Upgrade @types/express: ^5.0.3 → ^5.0.5
+- Dev: Upgrade @git.zone/tsbuild: ^2.6.4 → ^3.1.0
+- Dev: Upgrade @git.zone/tsbundle: ^2.5.1 → ^2.5.2
+- Dev: Upgrade @git.zone/tsrun: ^1.3.3 → ^2.0.0
+- Dev: Upgrade @git.zone/tstest: ^2.3.4 → ^2.8.2
+
+## 2025-09-03 - 3.0.79 - fix(servertools)
+Normalize Express wildcard parameter notation to /{*splat} across server routes and handlers; add local Claude settings
+
+- Replaced route pattern '/*splat' with '/{*splat}' in ts/classes.typedserver.ts and ts/servertools/tools.sslredirect.ts
+- Updated Express options route to use '/{*splat}' in ts/servertools/classes.server.ts
+- Clarified wildcard handling comments and array-join logic for splat params in ts/servertools/classes.handlerproxy.ts and ts/servertools/classes.handlerstatic.ts
+- Added .claude/settings.local.json containing local tool permissions for Claude/dev onboarding
+- No functional API changes — routing pattern normalization and comment/handler improvements only
+
+## 2025-09-03 - 3.0.78 - fix(servertools)
+Fix wildcard path extraction for static/proxy handlers, correct serviceworker route, add local settings and test typo fix
+
+- Make HandlerProxy and HandlerStatic robust to Express 5 wildcard param shapes (handle req.params.splat, numeric params, req.baseUrl and root routes) to correctly compute relative paths
+- Change serviceworker route registration to use '/serviceworker/*splat' (instead of previous pattern) for consistent wildcard handling
+- Fix test wording typo in test/test.server.ts ('exposer' -> 'expose')
+- Add .claude/settings.local.json with local tool permissions and add .serena/.gitignore to ignore /cache
+
+## 2025-08-17 - 3.0.77 - fix(servertools)
+Adjust route wildcard patterns and CORS handling; update serviceworker and SSL redirect patterns; bump express dependency; add local Claude settings
+
+- Normalize route wildcard patterns to use splat tokens (e.g. '/someroute/*' -> '/someroute/*splat', '/*' -> '/*splat') for consistent route matching
+- Update serviceworker route registration to '/serviceworker{.*}' and adjust related handler
+- Change SSL redirect route from '*' to '/*splat'
+- Adjust CORS preflight options path to '/*splat' and update tests to reflect new route patterns
+- Bump express dependency from ^4.21.2 to ^5.1.0
+- Add .claude/settings.local.json for local Claude tool permissions
+
+## 2025-08-16 - 3.0.76 - fix(handlerproxy)
+Use SmartRequest API and improve proxy/asset response handling; update tests and bump dependencies; add local project configuration files
+
+- Replace deprecated smartrequest.request usage with SmartRequest fluent API in ts/servertools/classes.handlerproxy.ts and add explicit handling for GET/POST/PUT/DELETE/PATCH methods.
+- Normalize proxied response body handling by using arrayBuffer()/text() and converting to Buffer to avoid body type inconsistencies.
+- Switch asset fetching in ts/utilityservers/classes.websiteserver.ts to SmartRequest + arrayBuffer for reliable binary handling.
+- Update tests (test/test.server.ts) to use SmartRequest.create() and to read response bodies via response.text(), matching the updated request API.
+- Bump dependencies: @push.rocks/smartrequest -> ^4.2.1 and body-parser -> ^2.2.0.
+- Add local project configuration files: .claude/settings.local.json and .serena/project.yml.
+
+## 2025-08-16 - 3.0.75 - fix(deps)
+Update dependencies, test tooling and test imports; enhance npm test script
+
+- Bump multiple runtime dependencies to newer patch/minor versions (notable updates: @cloudflare/workers-types, @push.rocks/* packages such as smartchok, smartfile, smartlog, smartpath, smartrx, and others, @tsclass/tsclass, @types/express, lit).
+- Upgrade dev tooling versions: @git.zone/tsbuild and @git.zone/tsbundle; update @git.zone/tstest to v2.3.4.
+- Improve npm test script by adding --verbose, --logfile and increased --timeout.
+- Fix test imports to use @git.zone/tstest/tapbundle in test/test.reload.ts and test/test.server.ts.
+
+## 2025-04-12 - 3.0.74 - fix(commit-info)
+chore: update commit metadata (no source code changes)
+
+- Uncommitted diff shows no changes in source files; the commit updates internal commit info only.
+
+## 2025-04-11 - 3.0.73 - fix(metadata)
+Update repository URLs and metadata to reflect the new organization scope
+
+- Changed gitscope from 'pushrocks' to 'api.global' in npmextra.json
+- Updated repository URL, bugs URL, and homepage in package.json to use code.foss.global/api.global/typedserver
+
 ## 2025-04-11 - 3.0.72 - fix(project)
 chore: no changes - commit metadata update

--- a/npmextra.json
+++ b/npmextra.json
@@ -6,7 +6,7 @@
    "projectType": "npm",
    "module": {
      "githost": "code.foss.global",
-      "gitscope": "pushrocks",
+      "gitscope": "api.global",
      "gitrepo": "typedserver",
      "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
      "npmPackagename": "@api.global/typedserver",
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@api.global/typedserver",
-  "version": "3.0.72",
+  "version": "7.8.8",
  "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
  "type": "module",
  "exports": {
@@ -13,15 +13,15 @@
    "./web_serviceworker_client": "./dist_ts_web_serviceworker_client/index.js"
  },
  "scripts": {
-    "test": "npm run build && tstest test/",
+    "test": "npm run build && tstest test/ --verbose --logfile --timeout 60",
    "build": "tsbuild tsfolders --web --allowimplicitany && npm run bundle",
-    "bundle": "tsbundle --from ./ts_web_inject/index.ts --to ./dist_ts_web_inject/bundle.js && tsbundle --from ./ts_web_serviceworker/index.ts --to ./dist_ts_web_serviceworker/serviceworker.bundle.js",
+    "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"
  },
  "repository": {
    "type": "git",
-    "url": "https://github.com/pushrocks/easyserve.git"
+    "url": "https://code.foss.global/api.global/typedserver.git"
  },
  "keywords": [
    "TypeScript",
@@ -32,7 +32,6 @@
    "HTTP server",
    "SSL",
    "cors",
-    "express middleware",
    "proxy",
    "sitemap",
    "feeds",
@@ -42,11 +41,12 @@
  "author": "Lossless GmbH <office@lossless.com> (https://lossless.com)",
  "license": "MIT",
  "bugs": {
-    "url": "https://github.com/pushrocks/easyserve/issues"
+    "url": "https://code.foss.global/api.global/typedserver/issues"
  },
  "files": [
    "ts/**/*",
    "ts_web/**/*",
+    "ts_swdash/**/*",
    "dist/**/*",
    "dist_*/**/*",
    "dist_ts/**/*",
@@ -56,21 +56,21 @@
    "npmextra.json",
    "readme.md"
  ],
-  "homepage": "https://github.com/pushrocks/easyserve",
+  "homepage": "https://code.foss.global/api.global/typedserver",
  "dependencies": {
-    "@api.global/typedrequest": "^3.1.10",
+    "@api.global/typedrequest": "^3.2.1",
    "@api.global/typedrequest-interfaces": "^3.0.19",
-    "@api.global/typedsocket": "^3.0.1",
-    "@cloudflare/workers-types": "^4.20250410.0",
+    "@api.global/typedsocket": "^4.1.0",
+    "@cloudflare/workers-types": "^4.20251202.0",
    "@design.estate/dees-comms": "^1.0.27",
-    "@push.rocks/lik": "^6.1.0",
-    "@push.rocks/smartchok": "^1.0.34",
+    "@push.rocks/lik": "^6.2.2",
    "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartenv": "^5.0.12",
-    "@push.rocks/smartfeed": "^1.0.11",
-    "@push.rocks/smartfile": "^11.2.0",
-    "@push.rocks/smartjson": "^5.0.20",
-    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartenv": "^6.0.0",
+    "@push.rocks/smartfeed": "^1.4.0",
+    "@push.rocks/smartfile": "^13.1.0",
+    "@push.rocks/smartfs": "^1.2.0",
+    "@push.rocks/smartjson": "^5.2.0",
+    "@push.rocks/smartlog": "^3.1.10",
    "@push.rocks/smartlog-destination-devtools": "^1.0.12",
    "@push.rocks/smartlog-interfaces": "^3.0.2",
    "@push.rocks/smartmanifest": "^2.0.2",
@@ -78,31 +78,27 @@
    "@push.rocks/smartmime": "^2.0.4",
    "@push.rocks/smartntml": "^2.0.8",
    "@push.rocks/smartopen": "^2.0.0",
-    "@push.rocks/smartpath": "^5.0.18",
+    "@push.rocks/smartpath": "^6.0.0",
    "@push.rocks/smartpromise": "^4.2.3",
-    "@push.rocks/smartrequest": "^2.1.0",
-    "@push.rocks/smartrx": "^3.0.7",
-    "@push.rocks/smartsitemap": "^2.0.3",
+    "@push.rocks/smartrequest": "^5.0.1",
+    "@push.rocks/smartrx": "^3.0.10",
+    "@push.rocks/smartserve": "^1.1.2",
+    "@push.rocks/smartsitemap": "^2.0.4",
    "@push.rocks/smartstream": "^3.2.5",
    "@push.rocks/smarttime": "^4.1.1",
-    "@push.rocks/taskbuffer": "^3.1.7",
-    "@push.rocks/webrequest": "^3.0.37",
+    "@push.rocks/smartwatch": "^5.0.0",
+    "@push.rocks/taskbuffer": "^3.5.0",
+    "@push.rocks/webrequest": "^4.0.1",
    "@push.rocks/webstore": "^2.0.20",
-    "@tsclass/tsclass": "^8.2.0",
-    "@types/express": "^5.0.1",
-    "body-parser": "^1.20.3",
-    "cors": "^2.8.5",
-    "express": "^4.21.2",
-    "express-force-ssl": "^0.3.2",
-    "lit": "^3.2.1"
+    "@tsclass/tsclass": "^9.3.0",
+    "lit": "^3.3.1"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.3.2",
-    "@git.zone/tsbundle": "^2.2.5",
-    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.96",
-    "@push.rocks/tapbundle": "^5.6.3",
-    "@types/node": "^22.14.0"
+    "@git.zone/tsbuild": "^3.1.2",
+    "@git.zone/tsbundle": "^2.6.3",
+    "@git.zone/tsrun": "^2.0.0",
+    "@git.zone/tstest": "^3.1.3",
+    "@types/node": "^24.10.1"
  },
  "private": false,
  "browserslist": [
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -1 +1,41 @@
- 
+# Project Hints - @api.global/typedserver
+
+## Recent Changes (December 2025)
+
+### Dependency Updates
+- `@push.rocks/smartchok` replaced with `@push.rocks/smartwatch` (renamed package, same API)
+- `@push.rocks/smartfile` upgraded from v11 to v13 (major API change - `fs` module removed)
+- `@push.rocks/smartfs` added for filesystem operations (v1.2.0+)
+- `@push.rocks/smartenv` upgraded to v6.0.0
+- `@push.rocks/smartrequest` upgraded to v5.0.1
+- `@push.rocks/webrequest` upgraded to v4.0.1 (`WebRequest` renamed to `WebrequestClient`)
+- Express upgraded to v5.2.1
+- All `@git.zone/*` dev dependencies updated to latest
+
+### Code Migration Notes
+
+#### smartfile v13 Migration
+- Old: `plugins.smartfile.fs.toStringSync(path)` / `plugins.smartfile.fs.toBufferSync(path)`
+- New: Use `plugins.fsInstance` (SmartFs instance with Node provider)
+  - String: `await plugins.fsInstance.file(path).encoding('utf8').read() as string`
+  - Buffer: `await plugins.fsInstance.file(path).read() as Buffer`
+
+#### smartfs treeHash
+- Old: `plugins.smartfile.fs.fileTreeToHash(dir, pattern)`
+- New: `await plugins.fsInstance.directory(dir).recursive().treeHash()`
+
+#### smartwatch (formerly smartchok)
+- Class renamed: `Smartchok` → `Smartwatch`
+- API remains the same: `new Smartwatch([paths])`, `.start()`, `.stop()`, `.getObservableFor(event)`
+
+#### webrequest v4
+- Class renamed: `WebRequest` → `WebrequestClient`
+
+### Architecture
+- `plugins.fsInstance` is a pre-configured SmartFs instance with SmartFsProviderNode
+- All file operations should be async using smartfs
+- Sync file operations have been removed
+
+### Express 5 Notes
+- Wildcard routes use `/{*splat}` notation
+- `req.params.splat` can be an array, use `Array.isArray()` check
--- a/readme.md
+++ b/readme.md
@@ -1,249 +1,278 @@
 # @api.global/typedserver

-A TypeScript-based framework for serving static files with advanced features including live reloading, compression, and type-safe API requests. Part of the @api.global ecosystem, it integrates seamlessly with @api.global/typedrequest for type-safe HTTP requests and @api.global/typedsocket for WebSocket communication.
+A powerful TypeScript-first web server framework featuring static file serving, live reload, compression, and seamless type-safe API integration. Part of the `@api.global` ecosystem, it provides a modern foundation for building full-stack TypeScript applications with first-class support for typed HTTP requests and WebSocket communication.

-## Features
+## Issue Reporting and Security

- **Type-Safe API Ecosystem**:
-  - HTTP Requests via @api.global/typedrequest
-  - WebSocket Support via @api.global/typedsocket
-  - Full TypeScript support across all endpoints
- **Service Worker Integration**: Advanced caching and offline capabilities
- **Edge Worker Support**: Optimized edge computing capabilities
- **Live Reload**: Automatic browser refresh on file changes
- **Compression**: Built-in support for response compression
- **CORS Management**: Flexible cross-origin resource sharing
- **TypeScript First**: Built with and for TypeScript
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.

-## Components
+## ✨ Features

-### Core Server (`ts/`)
- Static file serving with Express
- Type-safe request handling
- Live reload functionality
- Compression middleware
+- 🔒 **Type-Safe API Ecosystem** - Full TypeScript support with `@api.global/typedrequest` and `@api.global/typedsocket`
+- ⚡ **Live Reload** - Automatic browser refresh on file changes during development
+- 🗜️ **Compression** - Built-in support for gzip, deflate, and brotli compression
+- 🌐 **CORS Management** - Flexible cross-origin resource sharing configuration
+- 🔧 **Service Worker Integration** - Advanced caching and offline capabilities
+- ☁️ **Edge Worker Support** - Cloudflare Workers compatible edge computing
+- 📡 **WebSocket Support** - Real-time bidirectional communication via TypedSocket
+- 🗺️ **Sitemap & Feeds** - Automatic sitemap and RSS feed generation
+- 🤖 **Robots.txt** - Built-in robots.txt handling

-### Service Worker (`ts_web_serviceworker/`)
- `CacheManager`: Advanced caching strategies
- `NetworkManager`: Request/response handling
- `UpdateManager`: Cache invalidation and updates
- `ServiceWorker`: Core service worker implementation
-
-### Edge Worker (`ts_edgeworker/`)
- Edge computing capabilities
- Request/response transformation
- Edge caching strategies
-
-### Web Inject (`ts_web_inject/`)
- Live reload script injection
- Runtime dependency management
- Dynamic module loading
-
-## Installation
+## 📦 Installation

 ```bash
+# Using pnpm (recommended)
+pnpm add @api.global/typedserver
+
+# Using npm
 npm install @api.global/typedserver
 ```

-## Quick Start
+## 🚀 Quick Start
+
+### Basic Static File Server

 ```typescript
 import { TypedServer } from '@api.global/typedserver';

 const server = new TypedServer({
-  port: 3000,
  serveDir: './public',
-  watch: true,
-  compression: true
+  cors: true,
+  watch: true,           // Enable file watching
+  injectReload: true,    // Inject live reload script
 });

-server.start();
+await server.start();
+console.log('Server running on port 3000');
 ```

-## Type-Safe API Integration
+### Server with All Options

-### HTTP Requests with TypedRequest
 ```typescript
-import { TypedRequest } from '@api.global/typedrequest';
+import { TypedServer } from '@api.global/typedserver';

-// Define your request/response interface
-interface IUserRequest {
+const server = new TypedServer({
+  port: 8080,
+  serveDir: './dist',
+  cors: true,
+  watch: true,
+  injectReload: true,
+  enableCompression: true,
+  preferredCompressionMethod: 'brotli',
+  forceSsl: false,
+  sitemap: true,
+  feed: true,
+  robots: true,
+  domain: 'example.com',
+  appVersion: 'v1.0.0',
+  manifest: {
+    name: 'My App',
+    short_name: 'myapp',
+    start_url: '/',
+    display: 'standalone',
+    background_color: '#ffffff',
+    theme_color: '#000000',
+  },
+});
+
+await server.start();
+```
+
+## 🔌 Type-Safe API Integration
+
+### Adding TypedRequest Handlers
+
+```typescript
+import { TypedServer, servertools } from '@api.global/typedserver';
+import * as typedrequest from '@api.global/typedrequest';
+
+// Define your typed request interface
+interface IGetUser {
  method: 'getUser';
  request: { userId: string };
-  response: { username: string; email: string; };
+  response: { name: string; email: string };
 }

-// Create and use a typed request
-const getUserRequest = new TypedRequest<IUserRequest>('/api/users', 'getUser');
-const user = await getUserRequest.fire({ userId: '123' });
-```
+const server = new TypedServer({ serveDir: './public', cors: true });

-### WebSocket Communication
-```typescript
-import { TypedSocket } from '@api.global/typedsocket';
+// Create a typed router
+const typedRouter = new typedrequest.TypedRouter();

-// Server setup
-const typedRouter = new TypedRouter();
-const server = await TypedSocket.createServer(typedRouter);
-
-// Client connection
-const client = await TypedSocket.createClient(typedRouter, 'ws://localhost:3000');
-
-// Type-safe real-time messaging
-interface IChatMessage {
-  method: 'sendMessage';
-  request: { text: string };
-  response: { id: string; timestamp: number; };
-}
-```
-
-## Advanced Usage
-
-### Service Worker Setup
-
-```typescript
-import { ServiceWorker } from '@api.global/typedserver/web_serviceworker';
-
-const sw = new ServiceWorker({
-  cacheStrategy: 'network-first',
-  offlineSupport: true
-});
-
-sw.register();
-```
-
-### Edge Worker Configuration
-
-```typescript
-import { EdgeWorker } from '@api.global/typedserver/edgeworker';
-
-const edge = new EdgeWorker({
-  transforms: ['compress', 'minify'],
-  caching: true
-});
-```
-
-## Configuration
-
-### Server Options
-```typescript
-interface IServerOptions {
-  port?: number;
-  host?: string;
-  serveDir: string;
-  watch?: boolean;
-  compression?: boolean;
-  cors?: boolean | CorsOptions;
-  cache?: CacheOptions;
-}
-```
-
-### Cache Strategies
-```typescript
-type CacheStrategy = 
-  | 'network-first'
-  | 'cache-first'
-  | 'stale-while-revalidate';
-```
-
-## API Reference
-
-See [API Documentation](https://api.global/docs/typedserver) for detailed API reference.
-
-## Contributing
-
-1. Fork the repository
-2. Create your feature branch
-3. Commit your changes
-4. Push to the branch
-5. Create a Pull Request
-
-## License
-
-MIT License - see LICENSE for details.
-
-Task Venture Capital GmbH © 2024
-
-```typescript
-// Define a request type
-interface MyCustomRequest {
-  userId: string;
-}
-
-// Define a response type
-interface MyCustomResponse {
-  userName: string;
-}
-```
-
-Next, set up a route to handle requests using these types:
-
-```typescript
-import { TypedRouter, TypedHandler } from '@api.global/typedrequest';
-
-// Instantiate a TypedRouter
-const typedRouter = new TypedRouter();
-
-// Register a route with request and response types
-typedRouter.addTypedHandler<MyCustomRequest, MyCustomResponse>(
-  new TypedHandler('getUser', async (requestData) => {
-    // Implement your logic here. For example, fetch user data from a database.
-    const userData = { userName: 'John Doe' }; // Dummy implementation
-    return { response: userData };
+// Add a typed handler
+typedRouter.addTypedHandler<IGetUser>(
+  new typedrequest.TypedHandler('getUser', async (data) => {
+    // Your logic here
+    return { name: 'John Doe', email: 'john@example.com' };
  })
 );

-// Bind the typed router to the server
-typedServer.useTypedRouter(typedRouter);
+// Attach the router to the server
+server.server.addRoute('/api', new servertools.HandlerTypedRouter(typedRouter));

-// Now, the route is set up to handle requests with type checking
+await server.start();
 ```

-This example shows defining types for requests and responses, creating a `TypedRouter`, and adding a route with typed handling. This feature brings the benefits of TypeScript's static type checking to server-side logic, improving the development experience.
-
-### Enabling SSL/TLS
-
-To enable SSL/TLS, configure the `TypedServer` with the SSL options, including the paths to your SSL certificate and key files:
+### WebSocket Communication with TypedSocket

 ```typescript
-const serverOptions = {
-  port: 443,
-  serveDir: 'public',
-  watch: true,
-  injectReload: true,
+import { TypedServer } from '@api.global/typedserver';
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedsocket from '@api.global/typedsocket';
+
+const server = new TypedServer({ serveDir: './public', cors: true });
+const typedRouter = new typedrequest.TypedRouter();
+
+await server.start();
+
+// Create WebSocket server attached to the HTTP server
+const socketServer = await typedsocket.TypedSocket.createServer(
+  typedRouter,
+  server.server
+);
+
+// Handle real-time events
+interface IChatMessage {
+  method: 'sendMessage';
+  request: { text: string; room: string };
+  response: { messageId: string; timestamp: number };
+}
+
+typedRouter.addTypedHandler<IChatMessage>(
+  new typedrequest.TypedHandler('sendMessage', async (data) => {
+    return { messageId: crypto.randomUUID(), timestamp: Date.now() };
+  })
+);
+```
+
+## 🛠️ Server Tools
+
+### Custom Route Handlers
+
+```typescript
+import { servertools } from '@api.global/typedserver';
+
+const server = new servertools.Server({
  cors: true,
-  privateKey: fs.readFileSync('path/to/ssl/private.key'),
-  publicKey: fs.readFileSync('path/to/ssl/certificate.crt')
+  domain: 'example.com',
+});
+
+// Add a custom route with handler
+server.addRoute('/api/hello', new servertools.Handler('GET', async (req, res) => {
+  res.json({ message: 'Hello, World!' });
+}));
+
+// Serve static files from a directory
+server.addRoute('/{*splat}', new servertools.HandlerStatic('./public', {
+  serveIndexHtmlDefault: true,
+  enableCompression: true,
+}));
+
+await server.start(3000);
+```
+
+### Proxy Handler
+
+```typescript
+import { servertools } from '@api.global/typedserver';
+
+const server = new servertools.Server({ cors: true });
+
+// Proxy requests to another server
+server.addRoute('/proxy/{*splat}', new servertools.HandlerProxy({
+  target: 'https://api.example.com',
+}));
+
+await server.start(3000);
+```
+
+## ☁️ Edge Worker (Cloudflare Workers)
+
+```typescript
+import { EdgeWorker, DomainRouter } from '@api.global/typedserver/edgeworker';
+
+const router = new DomainRouter();
+
+router.addDomainInstruction({
+  domainPattern: '*.example.com',
+  originUrl: 'https://origin.example.com',
+  cacheConfig: { maxAge: 3600 },
+});
+
+const worker = new EdgeWorker(router);
+
+// In your Cloudflare Worker entry point
+export default {
+  fetch: (request: Request, env: any, ctx: any) => worker.handleRequest(request, env, ctx),
 };
-
-const typedServer = new TypedServer(serverOptions);
-startServer().catch(console.error);
 ```

-Replace `'path/to/ssl/private.key'` and `'path/to/ssl/certificate.crt'` with the actual paths to your SSL key and certificate files. This setup ensures that your server communicates over HTTPS, encrypting the data transmitted between the client and the server.
+## 🔧 Service Worker Client

-### Conclusion
+```typescript
+import { ServiceWorkerClient } from '@api.global/typedserver/web_serviceworker_client';

-`@api.global/typedserver` offers a streamlined way to set up a web server with TypeScript, featuring static file serving, live reloading, typed request/response handling, and SSL support. This guide covers the basic usage, but `TypedServer` is highly configurable, catering to various hosting and development needs.
+const swClient = new ServiceWorkerClient();
+
+// Register and manage service worker
+await swClient.register('/serviceworker.bundle.js');
+
+// Listen for updates
+swClient.onUpdate(() => {
+  console.log('New version available!');
+});
 ```

-For a deeper dive into the API and more advanced configurations, refer to the official documentation and type definitions included in the package.
+## 📋 Configuration Reference
+
+### IServerOptions
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `serveDir` | `string` | - | Directory to serve static files from |
+| `port` | `number \| string` | `3000` | Port to listen on |
+| `cors` | `boolean` | `true` | Enable CORS headers |
+| `watch` | `boolean` | `false` | Watch files for changes |
+| `injectReload` | `boolean` | `false` | Inject live reload script into HTML |
+| `enableCompression` | `boolean` | `false` | Enable response compression |
+| `preferredCompressionMethod` | `'gzip' \| 'deflate' \| 'brotli'` | - | Preferred compression algorithm |
+| `forceSsl` | `boolean` | `false` | Redirect HTTP to HTTPS |
+| `sitemap` | `boolean` | `false` | Generate sitemap at `/sitemap` |
+| `feed` | `boolean` | `false` | Generate RSS feed at `/feed` |
+| `robots` | `boolean` | `false` | Serve robots.txt |
+| `domain` | `string` | - | Domain name for sitemap/feeds |
+| `appVersion` | `string` | - | Application version string |
+| `manifest` | `object` | - | Web App Manifest configuration |
+| `publicKey` | `string` | - | SSL certificate |
+| `privateKey` | `string` | - | SSL private key |
+
+## 🏗️ Architecture
+
+```
+@api.global/typedserver
+├── /backend         - Main server exports (TypedServer, servertools)
+├── /edgeworker      - Cloudflare Workers edge computing
+├── /web_inject      - Live reload script injection
+├── /web_serviceworker - Service Worker implementation
+└── /web_serviceworker_client - Service Worker client utilities
+```

 ## License and Legal Information

-This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [LICENSE](./LICENSE) file.

 **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.

 ### Trademarks

-This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.

 ### Company Information

-Task Venture Capital GmbH  
-Registered at District court Bremen HRB 35230 HB, Germany
+Task Venture Capital GmbH
+Registered at District Court Bremen HRB 35230 HB, Germany

-For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+For any legal inquiries or further information, please contact us via email at hello@task.vc.

 By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
--- a/test/test.reload.ts
+++ b/test/test.reload.ts
@@ -1,4 +1,4 @@
-import { tap, expect } from '@push.rocks/tapbundle';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as smartpath from '@push.rocks/smartpath';

 import { TypedServer } from '../ts/index.js';
--- a/test/test.server.ts
+++ b/test/test.server.ts
@@ -1,5 +1,5 @@
 // tslint:disable-next-line:no-implicit-dependencies
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';

 // helper dependencies
 // tslint:disable-next-line:no-implicit-dependencies
@@ -48,7 +48,7 @@ tap.test('should create a valid Server', async () => {

 tap.test('should create a valid Route', async () => {
  testRoute = testServer.addRoute('/someroute');
-  testRoute2 = testServer.addRoute('/someroute/*');
+  testRoute2 = testServer.addRoute('/someroute/*splat');
  expect(testRoute).toBeInstanceOf(typedserver.servertools.Route);
 });

@@ -95,15 +95,18 @@ tap.test('should start the server allright', async () => {

 // see if a demo request holds up
 tap.test('should issue a request', async (tools) => {
-  const response = await smartrequest.postJson('http://127.0.0.1:3000/someroute', {
-    headers: {
+  const smartRequestInstance = smartrequest.SmartRequest.create();
+  const response = await smartRequestInstance
+    .url('http://127.0.0.1:3000/someroute')
+    .headers({
      'X-Forwarded-Proto': 'https',
-    },
-    requestBody: {
+    })
+    .json({
      someprop: 'hi',
-    },
-  });
-  console.log(response.body);
+    })
+    .post();
+  const responseBody = await response.text();
+  console.log(responseBody);
 });

 tap.test('should get a file from disk', async () => {
@@ -119,7 +122,7 @@ tap.test('should answer a preflight request', async () => {
  console.log(response.headers);
 });

-tap.test('should exposer a sitemap', async () => {
+tap.test('should expose a sitemap', async () => {
  const response = await fetch('http://127.0.0.1:3000/sitemap');
  console.log(await response.text());
 });
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: '@api.global/typedserver',
-  version: '3.0.72',
+  version: '7.8.0',
  description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }
--- a/ts/classes.typedserver.ts
+++ b/ts/classes.typedserver.ts
@@ -1,8 +1,9 @@
 import * as plugins from './plugins.js';
 import * as paths from './paths.js';
 import * as interfaces from '../dist_ts_interfaces/index.js';
-import * as servertools from './servertools/index.js';
-import { type TCompressionMethod } from './servertools/classes.compressor.js';
+import { DevToolsController } from './controllers/controller.devtools.js';
+import { TypedRequestController } from './controllers/controller.typedrequest.js';
+import { BuiltInRoutesController } from './controllers/controller.builtin.js';

 export interface IServerOptions {
  /**
@@ -15,16 +16,6 @@ export interface IServerOptions {
   */
  injectReload?: boolean;

-  /**
-   * enable compression
-   */
-  enableCompression?: boolean;
-
-  /**
-   * choose a preferred compression method
-   */
-  preferredCompressionMethod?: TCompressionMethod;
-
  /**
   * watch the serve directory?
   */
@@ -34,7 +25,6 @@ export interface IServerOptions {

  /**
   * a default answer given in case there is no other handler.
-   * @returns
   */
  defaultAnswer?: () => Promise<string>;

@@ -42,13 +32,14 @@ export interface IServerOptions {
   * will try to reroute traffic to an ssl connection using headers
   */
  forceSsl?: boolean;
+
  /**
   * allows serving manifests
   */
  manifest?: plugins.smartmanifest.ISmartManifestConstructorOptions;
+
  /**
   * the port to listen on
-   * can be overwritten when actually starting the server
   */
  port?: number | string;
  publicKey?: string;
@@ -57,6 +48,7 @@ export interface IServerOptions {
  feed?: boolean;
  robots?: boolean;
  domain?: string;
+
  /**
   * convey information about the app being served
   */
@@ -64,24 +56,56 @@ 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';
+
+export interface IRouteHandler {
+  (request: Request): Promise<Response | null>;
+}
+
+export interface IRegisteredRoute {
+  pattern: string;
+  regex: RegExp;
+  paramNames: string[];
+  method: THttpMethod;
+  handler: IRouteHandler;
 }

 export class TypedServer {
-  // static
-  // nothing here yet
-
  // instance
  public options: IServerOptions;
-  public server: servertools.Server;
-  public smartchokInstance: plugins.smartchok.Smartchok;
+  public smartServe: plugins.smartserve.SmartServe;
+  public smartwatchInstance: plugins.smartwatch.Smartwatch;
  public serveDirHashSubject = new plugins.smartrx.rxjs.ReplaySubject<string>(1);
  public serveHash: string = '000000';
  public typedsocket: plugins.typedsocket.TypedSocket;
  public typedrouter = new plugins.typedrequest.TypedRouter();

+  // Sitemap helper
+  private sitemapHelper: SitemapHelper;
+  private smartmanifestInstance: plugins.smartmanifest.SmartManifest;
+
+  // Decorated controllers
+  private devToolsController: DevToolsController;
+  private typedRequestController: TypedRequestController;
+  private builtInRoutesController: BuiltInRoutesController;
+
+  // File server for static files
+  private fileServer: plugins.smartserve.FileServer;
+
+  // Custom route handlers (for addRoute API)
+  private customRoutes: IRegisteredRoute[] = [];
+
  public lastReload: number = Date.now();
  public ended = false;
-  
+
  constructor(optionsArg: IServerOptions) {
    const standardOptions: IServerOptions = {
      port: 3000,
@@ -94,43 +118,64 @@ export class TypedServer {
      ...standardOptions,
      ...optionsArg,
    };
+  }

-    this.server = new servertools.Server(this.options);
-    // add routes to the smartexpress instance
-    this.server.addRoute(
-      '/typedserver/:request',
-      new servertools.Handler('ALL', async (req, res) => {
-        switch (req.params.request) {
-          case 'devtools':
-            res.setHeader('Content-Type', 'text/javascript');
-            res.status(200);
-            res.write(plugins.smartfile.fs.toStringSync(paths.injectBundlePath));
-            res.end();
-            break;
-          case 'reloadcheck':
-            console.log('got request for reloadcheck');
-            res.setHeader('Content-Type', 'text/plain');
-            res.status(200);
-            if (this.ended) {
-              res.write('end');
-              res.end();
-              return;
-            }
-            res.write(this.lastReload.toString());
-            res.end();
-            break;
-          default:
-            res.status(404);
-            res.write('Unknown request type');
-            res.end();
-            break;
-        }
+  /**
+   * Access sitemap URLs (for adding/replacing)
+   */
+  public get sitemap() {
+    return this.sitemapHelper;
+  }
+
+  /**
+   * Add a custom route handler
+   * Supports Express-style path patterns like '/path/:param' and '/path/*splat'
+   * @param path - The route path pattern
+   * @param method - HTTP method (GET, POST, PUT, DELETE, PATCH, ALL)
+   * @param handler - Async function that receives Request and returns Response or null
+   */
+  public addRoute(path: string, method: THttpMethod, handler: IRouteHandler): void {
+    // Convert Express-style path to regex
+    const paramNames: string[] = [];
+    let regexPattern = path
+      // Handle named parameters :param
+      .replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
+        paramNames.push(paramName);
+        return '([^/]+)';
      })
-    );
-    this.server.addRoute(
-      '/typedrequest',
-      new servertools.HandlerTypedRouter(this.typedrouter)
-    );
+      // Handle wildcard *splat (matches everything including slashes)
+      .replace(/\*([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
+        paramNames.push(paramName);
+        return '(.*)';
+      });
+
+    // Ensure exact match
+    regexPattern = `^${regexPattern}$`;
+
+    this.customRoutes.push({
+      pattern: path,
+      regex: new RegExp(regexPattern),
+      paramNames,
+      method,
+      handler,
+    });
+  }
+
+  /**
+   * Parse route parameters from a path using a registered route
+   */
+  private parseRouteParams(
+    route: IRegisteredRoute,
+    pathname: string
+  ): Record<string, string> | null {
+    const match = pathname.match(route.regex);
+    if (!match) return null;
+
+    const params: Record<string, string> = {};
+    route.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1];
+    });
+    return params;
  }

  /**
@@ -144,77 +189,122 @@ export class TypedServer {
      );
    }

-    if (this.options.serveDir) {
-      this.server.addRoute(
-        '/*',
-        new servertools.HandlerStatic(this.options.serveDir, {
-          responseModifier: async (responseArg) => {
-            if (plugins.path.parse(responseArg.path).ext === '.html') {
-              let fileString = responseArg.responseContent.toString();
-              const fileStringArray = fileString.split('<head>');
-              if (this.options.injectReload && fileStringArray.length === 2) {
-                fileStringArray[0] = `${fileStringArray[0]}<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 -->
-                `;
-                fileString = fileStringArray.join('');
-                console.log('injected typedserver script.');
-                responseArg.responseContent = Buffer.from(fileString);
-              } else if (this.options.injectReload) {
-                console.log('Could not insert typedserver script - no <head> tag found');
-              }
-            }
-            const headers = responseArg.headers;
-            headers.appHash = this.serveHash;
-            headers['Cache-Control'] = 'no-cache, no-store, must-revalidate';
-            headers['Pragma'] = 'no-cache';
-            headers['Expires'] = '0';
-            return {
-              headers,
-              path: responseArg.path,
-              responseContent: responseArg.responseContent,
-              travelData: responseArg.travelData,
-            };
-          },
-          serveIndexHtmlDefault: true,
-          enableCompression: this.options.enableCompression,
-          preferredCompressionMethod: this.options.preferredCompressionMethod,
-        })
-      );
+    const port =
+      typeof this.options.port === 'string'
+        ? parseInt(this.options.port, 10)
+        : this.options.port || 3000;
+
+    // Initialize optional helpers
+    if (this.options.sitemap) {
+      this.sitemapHelper = new SitemapHelper(this.options.domain);
    }
-    
+    if (this.options.manifest) {
+      this.smartmanifestInstance = new plugins.smartmanifest.SmartManifest(this.options.manifest);
+    }
+
+    // Initialize file server for static files
+    if (this.options.serveDir) {
+      this.fileServer = new plugins.smartserve.FileServer({
+        root: this.options.serveDir,
+        index: ['index.html'],
+        etag: true,
+      });
+    }
+
+    // Initialize decorated controllers
+    if (this.options.injectReload) {
+      this.devToolsController = new DevToolsController({
+        getLastReload: () => this.lastReload,
+        getEnded: () => this.ended,
+      });
+    }
+
+    this.typedRequestController = new TypedRequestController(this.typedrouter);
+
+    this.builtInRoutesController = new BuiltInRoutesController({
+      domain: this.options.domain,
+      robots: this.options.robots,
+      manifest: this.smartmanifestInstance,
+      sitemap: this.options.sitemap,
+      feed: this.options.feed,
+      appVersion: this.options.appVersion,
+      feedMetadata: this.options.feedMetadata,
+      articleGetterFunction: this.options.articleGetterFunction,
+      blockWaybackMachine: this.options.blockWaybackMachine,
+      getSitemapUrls: () => this.sitemapHelper?.urls || [],
+    });
+
+    // Register controllers with SmartServe's ControllerRegistry
+    if (this.options.injectReload) {
+      plugins.smartserve.ControllerRegistry.registerInstance(this.devToolsController);
+    }
+    plugins.smartserve.ControllerRegistry.registerInstance(this.typedRequestController);
+    plugins.smartserve.ControllerRegistry.registerInstance(this.builtInRoutesController);
+
+    // Compile routes for fast matching
+    plugins.smartserve.ControllerRegistry.compileRoutes();
+
+    // Build SmartServe options
+    const smartServeOptions: plugins.smartserve.ISmartServeOptions = {
+      port,
+      hostname: '0.0.0.0',
+      tls:
+        this.options.privateKey && this.options.publicKey
+          ? {
+              key: this.options.privateKey,
+              cert: this.options.publicKey,
+            }
+          : undefined,
+      websocket: {
+        typedRouter: this.typedrouter,
+        onConnectionOpen: (peer) => {
+          peer.tags.add('typedserver_frontend');
+          console.log(`WebSocket connected: ${peer.id}`);
+        },
+        onConnectionClose: (peer) => {
+          console.log(`WebSocket disconnected: ${peer.id}`);
+        },
+      },
+    };
+
+    this.smartServe = new plugins.smartserve.SmartServe(smartServeOptions);
+
+    // Set up custom request handler that integrates with ControllerRegistry
+    this.smartServe.setHandler(async (request: Request): Promise<Response> => {
+      return this.handleRequest(request);
+    });
+
+    // Setup file watching
    if (this.options.watch && this.options.serveDir) {
      try {
-        this.smartchokInstance = new plugins.smartchok.Smartchok([this.options.serveDir]);
-        await this.smartchokInstance.start();
-        (await this.smartchokInstance.getObservableFor('change')).subscribe(async () => {
+        // Use glob pattern to match all files recursively in serveDir
+        const watchGlob = this.options.serveDir.endsWith('/')
+          ? `${this.options.serveDir}**/*`
+          : `${this.options.serveDir}/**/*`;
+        this.smartwatchInstance = new plugins.smartwatch.Smartwatch([watchGlob]);
+        await this.smartwatchInstance.start();
+        (await this.smartwatchInstance.getObservableFor('change')).subscribe(async () => {
          await this.createServeDirHash();
          this.reload();
        });
        await this.createServeDirHash();
      } catch (error) {
        console.error('Failed to initialize file watching:', error);
-        // Continue without file watching rather than crashing
      }
    }

-    // lets start the server
-    await this.server.start();
+    // Start the server
+    await this.smartServe.start();
+    console.log(`TypedServer listening on port ${port}`);

+    // Setup TypedSocket using SmartServe integration
    try {
-      this.typedsocket = await plugins.typedsocket.TypedSocket.createServer(
-        this.typedrouter,
-        this.server
+      this.typedsocket = plugins.typedsocket.TypedSocket.fromSmartServe(
+        this.smartServe,
+        this.typedrouter
      );

-      // lets setup typedrouter
+      // Setup typedrouter handlers
      this.typedrouter.addTypedHandler<interfaces.IReq_GetLatestServerChangeTime>(
        new plugins.typedrequest.TypedHandler('getLatestServerChangeTime', async () => {
          return {
@@ -222,12 +312,292 @@ 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 chunkSizeKB = reqArg.chunkSizeKB || 64;
+          const sizeBytes = chunkSizeKB * 1024;
+          let payload: string | undefined;
+          let bytesTransferred = 0;
+
+          switch (reqArg.type) {
+            case 'download_chunk':
+              // Generate chunk data for download test
+              payload = 'x'.repeat(sizeBytes);
+              bytesTransferred = sizeBytes;
+              break;
+            case 'upload_chunk':
+              // Acknowledge received upload data
+              bytesTransferred = reqArg.payload?.length || 0;
+              break;
+            case 'latency':
+              // Simple ping - minimal data
+              bytesTransferred = 0;
+              break;
+          }
+
+          return { bytesTransferred, timestamp: Date.now(), payload };
+        })
+      );
    } catch (error) {
      console.error('Failed to initialize TypedSocket:', error);
-      // Continue without WebSocket support rather than crashing
    }
  }

+  /**
+   * Create an IRequestContext from a Request
+   */
+  private async createContext(
+    request: Request,
+    params: Record<string, string>
+  ): Promise<plugins.smartserve.IRequestContext> {
+    const url = new URL(request.url);
+    const method = request.method.toUpperCase() as THttpMethod;
+
+    // Parse query params
+    const query: Record<string, string> = {};
+    url.searchParams.forEach((value, key) => {
+      query[key] = value;
+    });
+
+    // Parse body
+    let body: unknown = undefined;
+    const contentType = request.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+      try {
+        body = await request.clone().json();
+      } catch {
+        body = {};
+      }
+    }
+
+    return {
+      request,
+      body,
+      params,
+      query,
+      headers: request.headers,
+      path: url.pathname,
+      method,
+      url,
+      runtime: 'node' as const,
+      state: {},
+    };
+  }
+
+  /**
+   * 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
+   */
+  private async handleRequest(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    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) {
+      try {
+        const context = await this.createContext(request, match.params);
+        const result = await match.route.handler(context);
+
+        // Handle Response or convert to Response
+        if (result instanceof Response) {
+          return result;
+        }
+        return new Response(JSON.stringify(result), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      } catch (error) {
+        if (error instanceof plugins.smartserve.RouteNotFoundError) {
+          // Route explicitly threw "not found", continue to other handlers
+        } else {
+          console.error('Controller error:', error);
+          return new Response('Internal Server Error', { status: 500 });
+        }
+      }
+    }
+
+    // Custom routes (registered via addRoute)
+    for (const route of this.customRoutes) {
+      if (route.method === 'ALL' || route.method === method) {
+        const params = this.parseRouteParams(route, path);
+        if (params !== null) {
+          (request as any).params = params;
+          const response = await route.handler(request);
+          if (response) return response;
+        }
+      }
+    }
+
+    // HTML injection for reload (if enabled)
+    if (this.options.injectReload && this.options.serveDir) {
+      const response = await this.handleHtmlWithInjection(request);
+      if (response) return response;
+    }
+
+    // Try static file serving
+    if (this.fileServer && (method === 'GET' || method === 'HEAD')) {
+      try {
+        const staticResponse = await this.fileServer.serve(request);
+        if (staticResponse) {
+          return staticResponse;
+        }
+      } catch (error) {
+        // Fall through to 404
+      }
+    }
+
+    // Default answer for root
+    if (path === '/' && method === 'GET' && this.options.defaultAnswer) {
+      const html = await this.options.defaultAnswer();
+      return new Response(html, {
+        status: 200,
+        headers: { 'Content-Type': 'text/html' },
+      });
+    }
+
+    // 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 });
+  }
+
+  /**
+   * Handle HTML files with reload script injection
+   */
+  private async handleHtmlWithInjection(request: Request): Promise<Response | null> {
+    const url = new URL(request.url);
+    const requestPath = url.pathname;
+
+    // Check if this is a request for an HTML file or root
+    if (requestPath === '/' || requestPath.endsWith('.html') || !requestPath.includes('.')) {
+      try {
+        let filePath = requestPath === '/' ? 'index.html' : requestPath.slice(1);
+        if (!filePath.endsWith('.html') && !filePath.includes('.')) {
+          filePath = plugins.path.join(filePath, 'index.html');
+        }
+
+        const fullPath = plugins.path.join(this.options.serveDir, filePath);
+
+        // Security check
+        if (!fullPath.startsWith(this.options.serveDir)) {
+          return new Response('Forbidden', { status: 403 });
+        }
+
+        let fileContent = (await plugins.fsInstance
+          .file(fullPath)
+          .encoding('utf8')
+          .read()) as string;
+
+        // Inject reload script
+        if (fileContent.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 -->
+              `;
+          fileContent = fileContent.replace('<head>', injection);
+          console.log('injected typedserver script.');
+        }
+
+        return new Response(fileContent, {
+          status: 200,
+          headers: {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Cache-Control': 'no-cache, no-store, must-revalidate',
+            Pragma: 'no-cache',
+            Expires: '0',
+            appHash: this.serveHash,
+          },
+        });
+      } catch (error) {
+        // Fall through to default handling
+      }
+    }
+
+    return null;
+  }
+
  /**
   * reloads the page
   */
@@ -237,14 +607,41 @@ export class TypedServer {
      console.warn('TypedSocket not initialized, skipping client notifications');
      return;
    }
-    
+
+    // Push cache invalidation to service workers first
    try {
-      const connections = await this.typedsocket.findAllTargetConnectionsByTag('typedserver_frontend');
+      const swConnections = await this.typedsocket.findAllTargetConnectionsByTag('serviceworker');
+      for (const connection of swConnections) {
+        const pushCacheInvalidate =
+          this.typedsocket.createTypedRequest<interfaces.serviceworker.IRequest_Serviceworker_CacheInvalidate>(
+            'serviceworker_cacheInvalidate',
+            connection
+          );
+        pushCacheInvalidate.fire({
+          reason: 'File change detected',
+          timestamp: this.lastReload,
+        }).catch(err => {
+          console.warn('Failed to push cache invalidation to service worker:', err);
+        });
+      }
+      if (swConnections.length > 0) {
+        console.log(`Pushed cache invalidation to ${swConnections.length} service worker(s)`);
+      }
+    } catch (error) {
+      console.warn('Failed to notify service workers:', error);
+    }
+
+    // Notify frontend clients
+    try {
+      const connections = await this.typedsocket.findAllTargetConnectionsByTag(
+        'typedserver_frontend'
+      );
      for (const connection of connections) {
-        const pushTime = this.typedsocket.createTypedRequest<interfaces.IReq_PushLatestServerChangeTime>(
-          'pushLatestServerChangeTime',
-          connection
-        );
+        const pushTime =
+          this.typedsocket.createTypedRequest<interfaces.IReq_PushLatestServerChangeTime>(
+            'pushLatestServerChangeTime',
+            connection
+          );
        pushTime.fire({
          time: this.lastReload,
        });
@@ -259,7 +656,7 @@ export class TypedServer {
   */
  public async stop(): Promise<void> {
    this.ended = true;
-    
+
    const stopWithErrorHandling = async (
      stopFn: () => Promise<unknown>,
      componentName: string
@@ -270,24 +667,24 @@ export class TypedServer {
        console.error(`Error stopping ${componentName}:`, err);
      }
    };
-    
+
    const tasks: Promise<void>[] = [];
-    
-    // Stop server
-    if (this.server) {
-      tasks.push(stopWithErrorHandling(() => this.server.stop(), 'server'));
+
+    // Stop SmartServe
+    if (this.smartServe) {
+      tasks.push(stopWithErrorHandling(() => this.smartServe.stop(), 'SmartServe'));
    }
-    
-    // Stop TypedSocket
+
+    // Stop TypedSocket (in SmartServe mode, this is a no-op but good for cleanup)
    if (this.typedsocket) {
      tasks.push(stopWithErrorHandling(() => this.typedsocket.stop(), 'TypedSocket'));
    }
-    
+
    // Stop file watcher
-    if (this.smartchokInstance) {
-      tasks.push(stopWithErrorHandling(() => this.smartchokInstance.stop(), 'file watcher'));
+    if (this.smartwatchInstance) {
+      tasks.push(stopWithErrorHandling(() => this.smartwatchInstance.stop(), 'file watcher'));
    }
-    
+
    await Promise.all(tasks);
  }

@@ -296,17 +693,57 @@ export class TypedServer {
   */
  public async createServeDirHash() {
    try {
-      const serveDirHash = await plugins.smartfile.fs.fileTreeToHash(this.options.serveDir, '**/*');
-      this.serveHash = serveDirHash;
-      console.log('Current ServeDir hash: ' + serveDirHash);
-      this.serveDirHashSubject.next(serveDirHash);
+      const serveDirHash = await plugins.fsInstance
+        .directory(this.options.serveDir)
+        .recursive()
+        .treeHash();
+      this.serveHash = serveDirHash.slice(0, 12);
+      console.log('Current ServeDir hash: ' + this.serveHash);
+      this.serveDirHashSubject.next(this.serveHash);
    } catch (error) {
      console.error('Failed to create serve directory hash:', error);
-      // Use a timestamp-based hash as fallback
      const fallbackHash = Date.now().toString(16).slice(-6);
      this.serveHash = fallbackHash;
      console.log('Using fallback hash: ' + fallbackHash);
      this.serveDirHashSubject.next(fallbackHash);
    }
  }
-}
+}
+
+// ============================================================================
+// Helper Classes
+// ============================================================================
+
+/**
+ * Sitemap helper class
+ */
+class SitemapHelper {
+  private smartSitemap = new plugins.smartsitemap.SmartSitemap();
+  public urls: plugins.smartsitemap.IUrlInfo[] = [];
+
+  constructor(domain?: string) {
+    if (domain) {
+      this.urls.push({
+        url: `https://${domain}/`,
+        timestamp: Date.now(),
+        frequency: 'daily',
+      });
+    }
+  }
+
+  async createSitemap(): Promise<string> {
+    return this.smartSitemap.createSitemapFromUrlInfoArray(this.urls);
+  }
+
+  async createSitemapNews(articles: plugins.tsclass.content.IArticle[]): Promise<string> {
+    return this.smartSitemap.createSitemapNewsFromArticleArray(articles);
+  }
+
+  replaceUrls(urlsArg: plugins.smartsitemap.IUrlInfo[]) {
+    this.urls = urlsArg;
+  }
+
+  addUrls(urlsArg: plugins.smartsitemap.IUrlInfo[]) {
+    this.urls = this.urls.concat(urlsArg);
+  }
+}
--- a/ts/controllers/controller.builtin.ts
+++ b/ts/controllers/controller.builtin.ts
@@ -0,0 +1,227 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+
+/**
+ * Built-in routes controller for TypedServer
+ * Handles robots.txt, manifest.json, sitemap, feed, appversion
+ */
+@plugins.smartserve.Route('')
+export class BuiltInRoutesController {
+  private options: {
+    domain?: string;
+    robots?: boolean;
+    manifest?: plugins.smartmanifest.SmartManifest;
+    sitemap?: boolean;
+    feed?: boolean;
+    appVersion?: string;
+    feedMetadata?: plugins.smartfeed.IFeedOptions;
+    articleGetterFunction?: () => Promise<plugins.tsclass.content.IArticle[]>;
+    blockWaybackMachine?: boolean;
+    getSitemapUrls: () => plugins.smartsitemap.IUrlInfo[];
+  };
+
+  constructor(options: typeof BuiltInRoutesController.prototype.options) {
+    this.options = options;
+  }
+
+  @plugins.smartserve.Get('/robots.txt')
+  async getRobots(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.robots || !this.options.domain) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const robotsContent = [
+      'User-agent: *',
+      'Allow: /',
+      `Sitemap: https://${this.options.domain}/sitemap`,
+    ];
+
+    if (this.options.blockWaybackMachine) {
+      robotsContent.push('', 'User-agent: ia_archiver', 'Disallow: /');
+    }
+
+    return new Response(robotsContent.join('\n'), {
+      status: 200,
+      headers: { 'Content-Type': 'text/plain' },
+    });
+  }
+
+  @plugins.smartserve.Get('/manifest.json')
+  async getManifest(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.manifest) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    return new Response(this.options.manifest.jsonString(), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sitemap')
+  async getSitemap(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.sitemap || !this.options.domain) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const smartsitemap = new plugins.smartsitemap.SmartSitemap();
+    const urls = this.options.getSitemapUrls();
+    const sitemapXml = await smartsitemap.createSitemapFromUrlInfoArray(urls);
+
+    return new Response(sitemapXml, {
+      status: 200,
+      headers: { 'Content-Type': 'application/xml' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sitemap-news')
+  async getSitemapNews(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.sitemap || !this.options.domain || !this.options.articleGetterFunction) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const smartsitemap = new plugins.smartsitemap.SmartSitemap();
+    const articles = await this.options.articleGetterFunction();
+    const sitemapNewsXml = await smartsitemap.createSitemapNewsFromArticleArray(articles);
+
+    return new Response(sitemapNewsXml, {
+      status: 200,
+      headers: { 'Content-Type': 'application/xml' },
+    });
+  }
+
+  @plugins.smartserve.Get('/feed')
+  async getFeed(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.feed || !this.options.feedMetadata) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const smartfeed = new plugins.smartfeed.Smartfeed();
+    const articles = this.options.articleGetterFunction
+      ? await this.options.articleGetterFunction()
+      : [];
+
+    const feedXml = await smartfeed.createFeedFromArticleArray(
+      this.options.feedMetadata,
+      articles
+    );
+
+    return new Response(feedXml, {
+      status: 200,
+      headers: { 'Content-Type': 'application/atom+xml' },
+    });
+  }
+
+  @plugins.smartserve.Get('/appversion')
+  async getAppVersion(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.appVersion) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    return new Response(this.options.appVersion, {
+      status: 200,
+      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 });
+    }
+  }
+}
--- a/ts/controllers/controller.devtools.ts
+++ b/ts/controllers/controller.devtools.ts
@@ -0,0 +1,53 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+
+/**
+ * DevTools controller for TypedServer
+ * Handles /typedserver/devtools and /typedserver/reloadcheck endpoints
+ */
+@plugins.smartserve.Route('/typedserver')
+export class DevToolsController {
+  private getLastReload: () => number;
+  private getEnded: () => boolean;
+
+  constructor(options: { getLastReload: () => number; getEnded: () => boolean }) {
+    this.getLastReload = options.getLastReload;
+    this.getEnded = options.getEnded;
+  }
+
+  @plugins.smartserve.Get('/devtools')
+  async getDevtools(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    const devtoolsContent = (await plugins.fsInstance
+      .file(paths.injectBundlePath)
+      .encoding('utf8')
+      .read()) as string;
+
+    return new Response(devtoolsContent, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/javascript',
+      },
+    });
+  }
+
+  @plugins.smartserve.Post('/reloadcheck')
+  async reloadCheck(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    console.log('got request for reloadcheck');
+
+    if (this.getEnded()) {
+      return new Response('end', {
+        status: 200,
+        headers: {
+          'Content-Type': 'text/plain',
+        },
+      });
+    }
+
+    return new Response(this.getLastReload().toString(), {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    });
+  }
+}
--- a/ts/controllers/controller.typedrequest.ts
+++ b/ts/controllers/controller.typedrequest.ts
@@ -0,0 +1,45 @@
+import * as plugins from '../plugins.js';
+
+/**
+ * TypedRequest controller for type-safe RPC endpoint
+ */
+@plugins.smartserve.Route('/typedrequest')
+export class TypedRequestController {
+  private typedRouter: plugins.typedrequest.TypedRouter;
+
+  constructor(typedRouter: plugins.typedrequest.TypedRouter) {
+    this.typedRouter = typedRouter;
+  }
+
+  @plugins.smartserve.Post('')
+  async handleTypedRequest(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 handleTypedRequestHead(): Promise<Response> {
+    // HEAD request for online checking from service worker
+    return new Response(null, {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+  }
+}
--- a/ts/controllers/index.ts
+++ b/ts/controllers/index.ts
@@ -0,0 +1,3 @@
+export * from './controller.devtools.js';
+export * from './controller.typedrequest.js';
+export * from './controller.builtin.js';
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -1,14 +1,6 @@
 import * as plugins from './plugins.js';

-import * as servertools from './servertools/index.js';
-
-export { servertools };
-
 export * from './classes.typedserver.js';
-// Type helpers
-export type Request = plugins.express.Request;
-export type Response = plugins.express.Response;
-

 // lets export utilityservers
 import * as utilityservers from './utilityservers/index.js';
--- a/ts/paths.ts
+++ b/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');
--- a/ts/plugins.ts
+++ b/ts/plugins.ts
@@ -3,7 +3,6 @@ import * as http from 'http';
 import * as https from 'https';
 import * as net from 'net';
 import * as path from 'path';
-import * as stream from 'stream';
 import * as zlib from 'zlib';

 export { http, https, net, path, zlib };
@@ -22,10 +21,11 @@ export { typedrequest, typedrequestInterfaces, typedsocket };

 // @pushrocks scope
 import * as lik from '@push.rocks/lik';
-import * as smartchok from '@push.rocks/smartchok';
+import * as smartwatch from '@push.rocks/smartwatch';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartfeed from '@push.rocks/smartfeed';
 import * as smartfile from '@push.rocks/smartfile';
+import * as smartfs from '@push.rocks/smartfs';
 import * as smartjson from '@push.rocks/smartjson';
 import * as smartmanifest from '@push.rocks/smartmanifest';
 import * as smartmime from '@push.rocks/smartmime';
@@ -40,10 +40,11 @@ import * as smarttime from '@push.rocks/smarttime';

 export {
  lik,
-  smartchok,
+  smartwatch,
  smartdelay,
  smartfeed,
  smartfile,
+  smartfs,
  smartjson,
  smartmanifest,
  smartmime,
@@ -57,11 +58,10 @@ export {
  smartrx,
 };

-// express
-import bodyParser from 'body-parser';
-import cors from 'cors';
-import express from 'express';
-// @ts-ignore
-import expressForceSsl from 'express-force-ssl';
+// Create a ready-to-use smartfs instance with Node.js provider
+export const fsInstance = new smartfs.SmartFs(new smartfs.SmartFsProviderNode());

-export { bodyParser, cors, express, expressForceSsl };
+// @push.rocks/smartserve
+import * as smartserve from '@push.rocks/smartserve';
+
+export { smartserve };
--- a/ts/servertools/classes.compressor.ts
+++ b/ts/servertools/classes.compressor.ts
@@ -1,131 +0,0 @@
-import * as plugins from '../plugins.js';
-
-export type TCompressionMethod = 'gzip' | 'deflate' | 'br' | 'none';
-export interface ICompressionResult {
-  result: Buffer;
-  compressionMethod: TCompressionMethod;
-}
-
-export class Compressor {
-  private _cache: Map<string, Buffer>;
-  private MAX_CACHE_SIZE: number = 100 * 1024 * 1024; // 100 MB
-
-  constructor() {
-    this._cache = new Map<string, Buffer>();
-  }
-
-  private _addToCache(key: string, value: Buffer) {
-    this._cache.set(key, value);
-    this._manageCacheSize();
-  }
-
-  private _manageCacheSize() {
-    let currentSize = Array.from(this._cache.values()).reduce((acc, buffer) => acc + buffer.length, 0);
-
-    while (currentSize > this.MAX_CACHE_SIZE) {
-      const firstKey = this._cache.keys().next().value;
-      const firstValue = this._cache.get(firstKey)!;
-      currentSize -= firstValue.length;
-      this._cache.delete(firstKey);
-    }
-  }
-
-  public async compressContent(
-    content: Buffer,
-    method: 'gzip' | 'deflate' | 'br' | 'none'
-  ): Promise<Buffer> {
-    const cacheKey = content.toString('base64') + method;
-    const cachedResult = this._cache.get(cacheKey);
-
-    if (cachedResult) {
-      return cachedResult;
-    }
-
-    return new Promise((resolve, reject) => {
-      const callback = (err: Error | null, result: Buffer) => {
-        if (err) reject(err);
-        else {
-          this._addToCache(cacheKey, result);
-          resolve(result);
-        }
-      };
-
-      switch (method) {
-        case 'gzip':
-          plugins.zlib.gzip(content, {
-            level: 1,
-          },callback,);
-          break;
-        case 'br':
-          plugins.zlib.brotliCompress(content, {}, callback);
-          break;
-        case 'deflate':
-          plugins.zlib.deflate(content, callback);
-          break;
-        default:
-          this._addToCache(cacheKey, content);
-          resolve(content);
-      }
-    });
-  }
-
-  public determineCompression(acceptEncoding: string | string[], preferredCompressionMethodsArg: TCompressionMethod[] = []) {
-    // Ensure acceptEncoding is a single string
-    const encodingString = Array.isArray(acceptEncoding)
-      ? acceptEncoding.join(', ')
-      : acceptEncoding;
-
-    let compressionMethod: TCompressionMethod = 'none';
-
-    // Prioritize preferred compression methods if provided
-    for (const preferredMethod of preferredCompressionMethodsArg) {
-      if (new RegExp(`\\b${preferredMethod}\\b`).test(encodingString)) {
-        return preferredMethod;
-      }
-    }
-
-    // Fallback to default prioritization if no preferred method matches
-    if (/\bbr\b/.test(encodingString)) {
-      compressionMethod = 'br';
-    } else if (/\bgzip\b/.test(encodingString)) {
-      compressionMethod = 'gzip';
-    } else if (/\bdeflate\b/.test(encodingString)) {
-      compressionMethod = 'deflate';
-    }
-
-    return compressionMethod;
-  }
-
-  public async maybeCompress(requestHeaders: plugins.http.IncomingHttpHeaders, content: Buffer, preferredCompressionMethodsArg?: TCompressionMethod[]): Promise<ICompressionResult> {
-    const acceptEncoding = requestHeaders['accept-encoding'];
-    const compressionMethod = this.determineCompression(acceptEncoding, preferredCompressionMethodsArg);
-    const result = await this.compressContent(content, compressionMethod);
-    return {
-      result,
-      compressionMethod,
-    };
-  }
-
-  public createCompressionStream(method: 'gzip' | 'deflate' | 'br' | 'none') {
-    let compressionStream: any;
-    switch (method) {
-      case 'gzip':
-        compressionStream = plugins.zlib.createGzip();
-        return compressionStream;
-      case 'br':
-        compressionStream = plugins.zlib.createBrotliCompress({
-          chunkSize: 16 * 1024,
-          params: {
-            
-          },
-        });
-        return compressionStream;
-      case 'deflate':
-        compressionStream = plugins.zlib.createDeflate();
-        return compressionStream;
-      default:
-        compressionStream = plugins.smartstream.createPassThrough();
-        return compressionStream;
-    }
-  }
-}
--- a/ts/servertools/classes.feed.ts
+++ b/ts/servertools/classes.feed.ts
@@ -1,35 +0,0 @@
-import { Handler } from './classes.handler.js';
-import { Server } from './classes.server.js';
-import * as plugins from '../plugins.js';
-
-export class Feed {
-  public smartexpressRef: Server;
-  public smartfeedInstance = new plugins.smartfeed.Smartfeed();
-
-  public feedHandler = new Handler('GET', async (req, res) => {
-    if (!this.smartexpressRef.options.feedMetadata) {
-      res.status(500);
-      res.write('feed metadata is missing');
-      res.end();
-      return;
-    }
-    if (!this.smartexpressRef.options.articleGetterFunction) {
-      res.status(500);
-      res.write('no article getter function defined.');
-      res.end();
-      return;
-    }
-    const xmlString = await this.smartfeedInstance.createFeedFromArticleArray(
-      this.smartexpressRef.options.feedMetadata,
-      await this.smartexpressRef.options.articleGetterFunction()
-    );
-    res.type('.xml');
-    res.write(xmlString);
-    res.end();
-  });
-
-  constructor(smartexpressRefArg: Server) {
-    this.smartexpressRef = smartexpressRefArg;
-    this.smartexpressRef.addRouteBefore('/feed', this.feedHandler);
-  }
-}
--- a/ts/servertools/classes.handler.ts
+++ b/ts/servertools/classes.handler.ts
@@ -1,17 +0,0 @@
-import * as plugins from '../plugins.js';
-import { type Request, type Response } from 'express';
-
-export interface IHandlerFunction {
-  (requestArg: Request, responseArg: Response): void;
-}
-
-export type THttpMethods = 'ALL' | 'GET' | 'POST' | 'PUT' | 'DELETE';
-
-export class Handler {
-  httpMethod: THttpMethods;
-  handlerFunction: IHandlerFunction;
-  constructor(httpMethodArg: THttpMethods, handlerArg: IHandlerFunction) {
-    this.httpMethod = httpMethodArg;
-    this.handlerFunction = handlerArg;
-  }
-}
--- a/ts/servertools/classes.handlerproxy.ts
+++ b/ts/servertools/classes.handlerproxy.ts
@@ -1,87 +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) => {
-      const relativeRequestPath = req.path.slice(req.route.path.length - 1);
-      const proxyRequestUrl = remoteMountPointArg + relativeRequestPath;
-      console.log(`proxy ${req.path} to ${proxyRequestUrl}`);
-      let proxiedResponse: plugins.smartrequest.IExtendedIncomingMessage;
-      try {
-        proxiedResponse = await plugins.smartrequest.request(proxyRequestUrl, {
-          method: req.method,
-          autoJsonParse: false,
-        });
-      } catch {
-        res.end('failed to fullfill request');
-        return;
-      }
-      for (const header of Object.keys(proxiedResponse.headers)) {
-        res.set(header, proxiedResponse.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]);
-        }
-      }
-
-      // Ensure body exists and convert it to Buffer consistently
-      let responseToSend: Buffer;
-      
-      if (proxiedResponse.body !== undefined && proxiedResponse.body !== null) {
-        if (Buffer.isBuffer(proxiedResponse.body)) {
-          responseToSend = proxiedResponse.body;
-        } else if (typeof proxiedResponse.body === 'string') {
-          responseToSend = Buffer.from(proxiedResponse.body);
-        } else {
-          // Handle other types (like objects) by JSON stringifying them
-          responseToSend = Buffer.from(JSON.stringify(proxiedResponse.body));
-        }
-      } else {
-        // Provide a default empty buffer if body is undefined/null
-        responseToSend = Buffer.from('');
-      }
-
-      if (optionsArg && optionsArg.responseModifier) {
-        const modifiedResponse = await optionsArg.responseModifier({
-          headers: res.getHeaders(),
-          path: req.path,
-          responseContent: responseToSend,
-        });
-
-        // headers
-        for (const key of Object.keys(res.getHeaders())) {
-          if (!modifiedResponse.headers[key]) {
-            res.removeHeader(key);
-          }
-        }
-
-        for (const key of Object.keys(modifiedResponse.headers)) {
-          res.setHeader(key, modifiedResponse.headers[key]);
-        }
-
-        // responseContent
-        responseToSend = modifiedResponse.responseContent;
-      }
-
-      res.status(200);
-      res.write(responseToSend);
-      res.end();
-    });
-  }
-}
--- a/ts/servertools/classes.handlerstatic.ts
+++ b/ts/servertools/classes.handlerstatic.ts
@@ -1,144 +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
-      let filePath: string = requestPath.slice(req.route.path.length - 1); // lets slice of the root
-      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 = plugins.smartfile.fs.toBufferSync(joinedPath);
-        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 = plugins.smartfile.fs.toBufferSync(defaultPath);
-            usedPath = defaultPath;
-          } catch (err) {
-            res.writeHead(500);
-            res.end('File not found!');
-            return;
-          }
-        } else {
-          res.writeHead(500);
-          res.end('File not found!');
-          return;
-        }
-      }
-
-      res.type(parsedPath.ext);
-
-      const headers = res.getHeaders();
-
-      // lets modify the response at last
-      if (optionsArg && optionsArg.responseModifier) {
-        const modifiedResponse = await optionsArg.responseModifier({
-          headers: res.getHeaders(),
-          path: usedPath,
-          responseContent: fileBuffer,
-          travelData,
-        });
-
-        // headers
-        for (const key of Object.keys(res.getHeaders())) {
-          if (!modifiedResponse.headers[key]) {
-            res.removeHeader(key);
-          }
-        }
-
-        for (const key of Object.keys(modifiedResponse.headers)) {
-          res.setHeader(key, modifiedResponse.headers[key]);
-        }
-
-        // responseContent
-        fileBuffer = modifiedResponse.responseContent;
-      }
-
-      // lets finally deal with compression
-      let compressionResult: ICompressionResult;
-
-      if (optionsArg && optionsArg.enableCompression) {
-        compressionResult = await this.compressor.maybeCompress(requestHeaders, fileBuffer, [optionsArg.preferredCompressionMethod]);
-      } else {
-        compressionResult = {
-          compressionMethod: 'none',
-          result: fileBuffer,
-        };
-      }
-
-      res.status(200);
-      if (compressionResult?.compressionMethod) {
-        res.header('Content-Encoding', compressionResult.compressionMethod);
-        res.write(compressionResult.result);
-      } else {
-        res.write(fileBuffer);
-      }
-      res.end();
-    });
-  }
-}
--- a/ts/servertools/classes.handlertypedrouter.ts
+++ b/ts/servertools/classes.handlertypedrouter.ts
@@ -1,19 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Handler } from './classes.handler.js';
-
-import * as interfaces from '../../dist_ts_interfaces/index.js';
-
-export class HandlerTypedRouter extends Handler {
-  /**
-   * The constuctor of HandlerProxy
-   * @param remoteMountPointArg
-   */
-  constructor(typedrouter: plugins.typedrequest.TypedRouter) {
-    super('POST', async (req, res) => {
-      const response = await typedrouter.routeAndAddResponse(req.body);
-      res.type('json');
-      res.write(plugins.smartjson.stringify(response));
-      res.end();
-    });
-  }
-}
--- a/ts/servertools/classes.route.ts
+++ b/ts/servertools/classes.route.ts
@@ -1,37 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Handler } from './classes.handler.js';
-import { Server } from './classes.server.js';
-
-import { type IRoute as IExpressRoute } from 'express';
-
-export class Route {
-  public routeString: string;
-
-  /**
-   * an object map of handlers
-   * Why multiple? Because GET, POST, PUT, DELETE, etc. can all have different handlers
-   */
-  public handlerObjectMap = new plugins.lik.ObjectMap<Handler>();
-  
-  public expressMiddlewareObjectMap = new plugins.lik.ObjectMap<any>();
-  public expressRoute: IExpressRoute; // will be set to server route on server start
-  constructor(ServerArg: Server, routeStringArg: string) {
-    this.routeString = routeStringArg;
-  }
-
-  /**
-   * add a handler to do something with requests
-   * @param handlerArg
-   */
-  public addHandler(handlerArg: Handler) {
-    this.handlerObjectMap.add(handlerArg);
-  }
-
-  /**
-   * add a express middleware
-   * @param middlewareArg
-   */
-  public addExpressMiddleWare(middlewareArg: plugins.express.Application) {
-    this.expressMiddlewareObjectMap.add(middlewareArg);
-  }
-}
--- a/ts/servertools/classes.server.ts
+++ b/ts/servertools/classes.server.ts
@@ -1,338 +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));
-  }
-
-  public addTypedSocket(typedrouter: plugins.typedrequest.TypedRouter): void {
-    this.executeAfterStartFunctions.push(async () => {
-      plugins.typedsocket.TypedSocket.createServer(typedrouter, this);
-    });
-  }
-
-  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('/*', cors);
-    }
-
-    this.expressAppInstance.use((req, res, next) => {
-      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
-      res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
-      res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
-      res.setHeader('Access-Control-Allow-Origin', '*');
-      res.setHeader('SERVEZONE_ROUTE', 'LOSSLESS_ORIGIN_CONTAINER');
-      res.setHeader('Cache-Control', 'no-cache');
-      res.setHeader('Expires', new Date(Date.now()).toUTCString());
-      next();
-    });
-
-    // body parsing
-    this.expressAppInstance.use(async (req, res, next) => {
-      if (req.headers['content-type'] === 'application/json') {
-        let data = '';
-        req.on('data', chunk => {
-          data += chunk;
-        });
-        req.on('end', () => {
-          try {
-            req.body = plugins.smartjson.parse(data);
-            next();
-          } catch (error) {
-            res.status(400).send('Invalid JSON');
-          }
-        });
-      } else {
-        next();
-      }
-    });
-    this.expressAppInstance.use(plugins.bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded
-
-    // robots
-    if (this.options.robots && this.options.domain) {
-      await setupRobots(this, this.options.domain);
-    }
-
-    // manifest.json
-    if (this.options.manifest) {
-      await setupManifest(this.expressAppInstance, this.options.manifest);
-    }
-
-    // sitemaps
-    if (this.options.sitemap) {
-      this.sitemap = new Sitemap(this);
-    }
-
-    if (this.options.feed) {
-      // feed
-      this.feed = new Feed(this);
-    }
-
-    // appVersion
-    if (this.options.appVersion) {
-      this.expressAppInstance.use((req, res, next) => {
-        res.set('appversion', this.options.appVersion);
-        next();
-      });
-      this.addRoute(
-        '/appversion',
-        new Handler('GET', async (req, res) => {
-          res.write(this.options.appVersion);
-          res.end();
-        })
-      );
-    }
-
-    // set up routes in for express
-    await this.routeObjectMap.forEach(async (routeArg) => {
-      console.log(
-        `"${routeArg.routeString}" maps to ${routeArg.handlerObjectMap.getArray().length} handlers`
-      );
-      const expressRoute = this.expressAppInstance.route(routeArg.routeString);
-      routeArg.handlerObjectMap.forEach(async (handler) => {
-        console.log(` -> ${handler.httpMethod}`);
-        switch (handler.httpMethod) {
-          case 'GET':
-            expressRoute.get(handler.handlerFunction);
-            return;
-          case 'POST':
-            expressRoute.post(handler.handlerFunction);
-            return;
-          case 'PUT':
-            expressRoute.put(handler.handlerFunction);
-            return;
-          case 'ALL':
-            expressRoute.all(handler.handlerFunction);
-            return;
-          case 'DELETE':
-            expressRoute.delete(handler.handlerFunction);
-            return;
-          default:
-            return;
-        }
-      });
-    });
-
-    if (this.options.defaultAnswer) {
-      this.expressAppInstance.get('/', async (request, response) => {
-        response.send(await this.options.defaultAnswer());
-      });
-    }
-
-    this.httpServer.on('connection', (connection: plugins.net.Socket) => {
-      this.socketMap.add(connection);
-      console.log(`added connection. now ${this.socketMap.getArray().length} sockets connected.`);
-      
-      const closeListener = () => {
-        console.log('connection closed');
-        cleanupConnection();
-      };
-      
-      const errorListener = () => {
-        console.log('connection errored');
-        cleanupConnection();
-      };
-      
-      const endListener = () => {
-        console.log('connection ended');
-        cleanupConnection();
-      };
-      
-      const timeoutListener = () => {
-        console.log('connection timed out');
-        cleanupConnection();
-      };
-      
-      connection.addListener('close', closeListener);
-      connection.addListener('error', errorListener);
-      connection.addListener('end', endListener);
-      connection.addListener('timeout', timeoutListener);
-      
-      const cleanupConnection = async () => {
-        connection.removeListener('close', closeListener);
-        connection.removeListener('error', errorListener);
-        connection.removeListener('end', endListener);
-        connection.removeListener('timeout', timeoutListener);
-        
-        if (this.socketMap.checkForObject(connection)) {
-          this.socketMap.remove(connection);
-          console.log(`removed connection. ${this.socketMap.getArray().length} sockets remaining.`);
-          await plugins.smartdelay.delayFor(0);
-          if (connection.destroyed === false) {
-            connection.destroy();
-          }
-        }
-      };
-    });
-
-    // finally listen on a port
-    if (doListen) {
-      this.httpServer.listen(portArg, '0.0.0.0', () => {
-        console.log(`now listening on ${portArg}!`);
-        this.startedDeferred.resolve();
-        this.serverStatus = 'running';
-        done.resolve();
-      });
-    } else {
-      console.log(
-        'The server does not listen on a network stack and instead expects to get handed requests by other mechanics'
-      );
-    }
-    await done.promise;
-    for (const executeAfterStartFunction of this.executeAfterStartFunctions) {
-      await executeAfterStartFunction();
-    }
-  }
-
-  public getHttpServer() {
-    return this.httpServer;
-  }
-
-  public getExpressAppInstance() {
-    return this.expressAppInstance;
-  }
-
-  public async stop() {
-    const done = plugins.smartpromise.defer();
-    if (this.httpServer) {
-      this.httpServer.close(async () => {
-        this.serverStatus = 'stopped';
-        done.resolve();
-      });
-      await this.socketMap.forEach(async (socket) => {
-        socket.destroy();
-      });
-    } else {
-      throw new Error('There is no Server to be stopped. Have you started it?');
-    }
-    return await done.promise;
-  }
-
-  /**
-   * allows handling requests and responses that come from other
-   * @param req
-   * @param res
-   */
-  public async handleReqRes(req: plugins.express.Request, res: plugins.express.Response) {
-    this.expressAppInstance(req, res);
-  }
-}
--- a/ts/servertools/classes.sitemap.ts
+++ b/ts/servertools/classes.sitemap.ts
@@ -1,68 +0,0 @@
-import { Server } from './classes.server.js';
-import { Handler } from './classes.handler.js';
-import * as plugins from '../plugins.js';
-import { type IUrlInfo } from '@push.rocks/smartsitemap';
-
-export class Sitemap {
-  public smartexpressRef: Server;
-  public smartSitemap = new plugins.smartsitemap.SmartSitemap();
-  public urls: plugins.smartsitemap.IUrlInfo[] = [];
-
-  /**
-   * handles the normal sitemap request
-   */
-  public sitemapHandler = new Handler('GET', async (req, res) => {
-    const sitemapXmlString = await this.smartSitemap.createSitemapFromUrlInfoArray(this.urls);
-    res.type('.xml');
-    res.write(sitemapXmlString);
-    res.end();
-  });
-
-  /**
-   * handles the sitemap-news request
-   */
-  public sitemapNewsHandler = new Handler('GET', async (req, res) => {
-    if (!this.smartexpressRef.options.articleGetterFunction) {
-      res.status(500);
-      res.write('no article getter function defined.');
-      res.end();
-      return;
-    }
-    const sitemapNewsXml = await this.smartSitemap.createSitemapNewsFromArticleArray(
-      await this.smartexpressRef.options.articleGetterFunction()
-    );
-    res.type('.xml');
-    res.write(sitemapNewsXml);
-    res.end();
-  });
-
-  constructor(smartexpressRefArg: Server) {
-    this.smartexpressRef = smartexpressRefArg;
-    this.smartexpressRef.addRouteBefore('/sitemap', this.sitemapHandler);
-    this.smartexpressRef.addRouteBefore('/sitemap-news', this.sitemapNewsHandler);
-
-    // lets set the default url
-    if (this.smartexpressRef.options.domain) {
-      this.urls.push({
-        url: `https://${this.smartexpressRef.options.domain}/`,
-        timestamp: Date.now(),
-        frequency: 'daily',
-      });
-    }
-  }
-
-  /**
-   * replaces the current urlsArray
-   * @param urlsArg
-   */
-  public replaceUrls(urlsArg: IUrlInfo[]) {
-    this.urls = urlsArg;
-  }
-
-  /**
-   * adds urls to the current set of urls
-   */
-  public addUrls(urlsArg: IUrlInfo[]) {
-    this.urls = this.urls.concat(urlsArg);
-  }
-}
--- a/ts/servertools/index.ts
+++ b/ts/servertools/index.ts
@@ -1,12 +0,0 @@
-export * from './classes.server.js';
-export * from './classes.route.js';
-export * from './classes.handler.js';
-export * from './classes.handlerstatic.js';
-export * from './classes.handlerproxy.js';
-export * from './classes.handlertypedrouter.js';
-export * from './classes.compressor.js';
-import * as serviceworker from './tools.serviceworker.js';
-
-export {
-  serviceworker,
-}
--- a/ts/servertools/tools.manifest.ts
+++ b/ts/servertools/tools.manifest.ts
@@ -1,14 +0,0 @@
-import * as plugins from '../plugins.js';
-
-export const setupManifest = async (
-  expressInstanceArg: plugins.express.Application,
-  manifestArg: plugins.smartmanifest.ISmartManifestConstructorOptions
-) => {
-  const smartmanifestInstance = new plugins.smartmanifest.SmartManifest(manifestArg);
-  expressInstanceArg.get('/manifest.json', async (req, res) => {
-    res.status(200);
-    res.type('json');
-    res.write(smartmanifestInstance.jsonString());
-    res.end();
-  });
-};
--- a/ts/servertools/tools.robots.ts
+++ b/ts/servertools/tools.robots.ts
@@ -1,33 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Server } from './classes.server.js';
-import { Handler } from './classes.handler.js';
-
-export const setupRobots = async (smartexpressRefArg: Server, domainArg: string) => {
-  smartexpressRefArg.addRouteBefore(
-    '/robots.txt',
-    new Handler('GET', async (req, res) => {
-      res.type('text/plain');
-      res.send(`
-User-agent: Googlebot-News
-Disallow: /account
-Disallow: /login
-
-User-agent: *
-Disallow: /account
-Disallow: /login
-
-${
-  smartexpressRefArg.options.blockWaybackMachine
-    ? `
-User-Agent: ia_archiver
-Disallow: /
-`
-    : ``
-}
-
-Sitemap: https://${domainArg}/sitemap
-Sitemap: https://${domainArg}/sitemap-news
-`);
-    })
-  );
-};
--- a/ts/servertools/tools.serviceworker.ts
+++ b/ts/servertools/tools.serviceworker.ts
@@ -1,60 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as paths from '../paths.js';
-
-import * as interfaces from '../../dist_ts_interfaces/index.js'
-import { Handler } from './classes.handler.js';
-import type { TypedServer } from '../classes.typedserver.js';
-import { HandlerTypedRouter } from './classes.handlertypedrouter.js';
-
-const swBundleJs: string = plugins.smartfile.fs.toStringSync(
-  plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js')
-);
-const swBundleJsMap: string = plugins.smartfile.fs.toStringSync(
-  plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js.map')
-);
-let swVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
-  null;
-const serviceworkerHandler = new Handler(
-  'GET',
-  async (req, res) => {
-    if (req.path === '/serviceworker.bundle.js') {
-      res.status(200);
-      res.set('Content-Type', 'text/javascript');
-      res.write(swBundleJs + '\n' + `/** appSemVer: ${swVersionInfo?.appSemVer || 'not set'} */`);
-    } else if (req.path === '/serviceworker.bundle.js.map') {
-      res.status(200);
-      res.set('Content-Type', 'application/json');
-      res.write(swBundleJsMap);
-    }
-    res.end();
-  }
-);
-
-export const addServiceWorkerRoute = (
-  typedserverInstance: TypedServer,
-  swDataFunc: () => interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response']
-) => {
-  // lets the version info as unique string;
-  swVersionInfo = swDataFunc();
-
-  // the basic stuff
-  typedserverInstance.server.addRoute('/serviceworker.*', serviceworkerHandler);
-
-  // the typed stuff
-  const typedrouter = new plugins.typedrequest.TypedRouter();
-
-  typedrouter.addTypedHandler(
-    new plugins.typedrequest.TypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>(
-      'serviceworker_versionInfo',
-      async (req) => {
-        const versionInfoResponse = swDataFunc();
-        return versionInfoResponse;
-      }
-    )
-  );
-
-  typedserverInstance.server.addRoute(
-    '/sw-typedrequest',
-    new HandlerTypedRouter(typedrouter)
-  );
-};
--- a/ts/servertools/tools.sslredirect.ts
+++ b/ts/servertools/tools.sslredirect.ts
@@ -1,22 +0,0 @@
-import * as plugins from '../plugins.js';
-import { Server } from './classes.server.js';
-import { Handler } from './classes.handler.js';
-
-export const redirectFrom80To443 = async () => {
-  const smartexpressInstance = new Server({
-    cors: true,
-    forceSsl: true,
-    port: 80,
-  });
-
-  smartexpressInstance.addRoute(
-    '*',
-    new Handler('ALL', async (req, res) => {
-      res.redirect('https://' + req.headers.host + req.url);
-    })
-  );
-
-  await smartexpressInstance.start();
-
-  return smartexpressInstance;
-};
--- a/ts/utilityservers/classes.serviceserver.ts
+++ b/ts/utilityservers/classes.serviceserver.ts
@@ -1,9 +1,7 @@
 import { TypedServer } from '../classes.typedserver.js';
-import * as servertools from '../servertools/index.js';
-import * as plugins from '../plugins.js';

 export interface ILoleServiceServerConstructorOptions {
-  addCustomRoutes?: (serverArg: servertools.Server) => Promise<any>;
+  addCustomRoutes?: (typedserver: TypedServer) => Promise<any>;
  serviceName: string;
  serviceVersion: string;
  serviceDomain: string;
@@ -20,12 +18,12 @@ export class UtilityServiceServer {
  }

  public async start() {
-    console.log('starting lole-serviceserver...')
+    console.log('starting lole-serviceserver...');
    this.typedServer = new TypedServer({
      cors: true,
      domain: this.options.serviceDomain,
      forceSsl: false,
-      port: this.options.port || 3000,
+      port: this.options.port || 3000,
      robots: true,
      defaultAnswer: async () => {
        const InfoHtml = (await import('../infohtml/index.js')).InfoHtml;
@@ -37,9 +35,9 @@ export class UtilityServiceServer {
      },
    });

-    // lets add any custom routes
+    // Add any custom routes
    if (this.options.addCustomRoutes) {
-      await this.options.addCustomRoutes(this.typedServer.server);
+      await this.options.addCustomRoutes(this.typedServer);
    }

    await this.typedServer.start();
--- a/ts/utilityservers/classes.websiteserver.ts
+++ b/ts/utilityservers/classes.websiteserver.ts
@@ -1,11 +1,9 @@
 import * as interfaces from '../../dist_ts_interfaces/index.js';
 import { type IServerOptions, TypedServer } from '../classes.typedserver.js';
-import type { Request, Response } from '../index.js';
 import * as plugins from '../plugins.js';
-import * as servertools from '../servertools/index.js';

 export interface IUtilityWebsiteServerConstructorOptions {
-  addCustomRoutes?: (serverArg: servertools.Server) => Promise<any>;
+  addCustomRoutes?: (typedserver: TypedServer) => Promise<any>;
  appSemVer?: string;
  domain: string;
  serveDir: string;
@@ -16,7 +14,6 @@ export interface IUtilityWebsiteServerConstructorOptions {
 * the utility website server implements a best practice server for websites
 * It supports:
 *  * live reload
- *  * compression
 *  * serviceworker
 *  * pwa manifest
 */
@@ -30,7 +27,7 @@ export class UtilityWebsiteServer {
  }

  /**
-   *
+   * Start the website server
   */
  public async start(portArg = 3000) {
    this.typedserver = new TypedServer({
@@ -38,8 +35,6 @@ export class UtilityWebsiteServer {
      injectReload: true,
      watch: true,
      serveDir: this.options.serveDir,
-      enableCompression: true,
-      preferredCompressionMethod: 'gzip',
      domain: this.options.domain,
      forceSsl: false,
      manifest: {
@@ -58,33 +53,34 @@ export class UtilityWebsiteServer {
      sitemap: true,
    });

-    let lswData: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
-      {
-        appHash: 'xxxxxx',
-        appSemVer: this.options.appSemVer || 'x.x.x',
-      };
+    let lswData: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] = {
+      appHash: 'xxxxxx',
+      appSemVer: this.options.appSemVer || 'x.x.x',
+    };

-    // -> /lsw* - anything regarding serviceworker
-    servertools.serviceworker.addServiceWorkerRoute(this.typedserver, () => {
-      return lswData;
-    });
-
-    // lets add ads.txt
-    this.typedserver.server.addRoute(
-      '/ads.txt',
-      new servertools.Handler('GET', async (req, res) => {
-        res.type('txt/plain');
-        const adsTxt =
-          ['google.com, pub-4104137977476459, DIRECT, f08c47fec0942fa0'].join('\n') + '\n';
-        res.write(adsTxt);
-        res.end();
+    // -> Service worker version info handler
+    this.typedserver.typedrouter.addTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>(
+      new plugins.typedrequest.TypedHandler('serviceworker_versionInfo', async () => {
+        return lswData;
      })
    );

-    this.typedserver.server.addRoute(
+    // ads.txt handler
+    this.typedserver.addRoute('/ads.txt', 'GET', async () => {
+      const adsTxt =
+        ['google.com, pub-4104137977476459, DIRECT, f08c47fec0942fa0'].join('\n') + '\n';
+      return new Response(adsTxt, {
+        status: 200,
+        headers: { 'Content-Type': 'text/plain' },
+      });
+    });
+
+    // Asset broker manifest handler
+    this.typedserver.addRoute(
      '/assetbroker/manifest/:manifestAsset',
-      new servertools.Handler('GET', async (req, res) => {
-        let manifestAssetName = req.params.manifestAsset;
+      'GET',
+      async (request: Request) => {
+        let manifestAssetName = (request as any).params?.manifestAsset;
        if (manifestAssetName === 'favicon.png') {
          manifestAssetName = `favicon_${this.options.domain
            .replace('.', '')
@@ -92,19 +88,22 @@ export class UtilityWebsiteServer {
        }
        const fullOriginAssetUrl = `https://assetbroker.lossless.one/brandfiles/00general/${manifestAssetName}`;
        console.log(`Getting ${manifestAssetName} from ${fullOriginAssetUrl}`);
-        const dataBuffer: Buffer = (await plugins.smartrequest.getBinary(fullOriginAssetUrl)).body;
-        res.type('.png');
-        res.write(dataBuffer);
-        res.end();
-      })
+        const smartRequest = plugins.smartrequest.SmartRequest.create();
+        const response = await smartRequest.url(fullOriginAssetUrl).get();
+        const arrayBuffer = await response.arrayBuffer();
+        return new Response(arrayBuffer, {
+          status: 200,
+          headers: { 'Content-Type': 'image/png' },
+        });
+      }
    );

-    // lets add any custom routes
+    // Add any custom routes
    if (this.options.addCustomRoutes) {
-      await this.options.addCustomRoutes(this.typedserver.server);
+      await this.options.addCustomRoutes(this.typedserver);
    }

-    // -> /*  - serve the files
+    // Subscribe to serve directory hash changes
    this.typedserver.serveDirHashSubject.subscribe((appHash: string) => {
      lswData = {
        appHash,
@@ -112,11 +111,11 @@ export class UtilityWebsiteServer {
      };
    });

-    // lets setup the typedrouter chain
+    // Setup the typedrouter chain
    this.typedserver.typedrouter.addTypedRouter(this.typedrouter);

-    // lets start everything
-    console.log('routes are all set. Startin up now!');
+    // Start everything
+    console.log('routes are all set. Starting up now!');
    await this.typedserver.start();
    console.log('typedserver started!');
  }
@@ -124,14 +123,4 @@ export class UtilityWebsiteServer {
  public async stop() {
    await this.typedserver.stop();
  }
-
-  /**
-   * allows you to hanlde requests from other server instances without the need to listen for yourself
-   * note smartexpress allows you start the instance wuith passing >>false<< as second parameter to .start();
-   * @param req
-   * @param res
-   */
-  public async handleRequest(req: Request, res: Response) {
-    await this.typedserver.server.handleReqRes(req, res);
-  }
 }
--- a/ts_interfaces/serviceworker.ts
+++ b/ts_interfaces/serviceworker.ts
@@ -124,4 +124,518 @@ export interface IRequest_Client_Serviceworker_ConnectionPolling
  response: {
    serviceworkerId: string;
  }
-}
+}
+
+// ===============
+// Metrics interfaces
+// ===============
+
+/**
+ * Request to get service worker metrics
+ */
+export interface IRequest_Serviceworker_Metrics
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_Metrics
+  > {
+  method: 'serviceworker_metrics';
+  request: {};
+  response: {
+    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;
+    };
+    startTime: number;
+    uptime: number;
+  };
+}
+
+// ===============
+// Connection result interface
+// ===============
+
+/**
+ * Result of a service worker connection attempt
+ */
+export interface IConnectionResult {
+  connected: boolean;
+  error?: string;
+  attempts?: number;
+  duration?: number;
+}
+
+// ===============
+// Speedtest interfaces
+// ===============
+
+/**
+ * Cache invalidation request from server to service worker
+ */
+export interface IRequest_Serviceworker_CacheInvalidate
+  extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_CacheInvalidate
+  > {
+  method: 'serviceworker_cacheInvalidate';
+  request: {
+    reason: string;
+    timestamp: number;
+  };
+  response: {
+    success: boolean;
+  };
+}
+
+/**
+ * Speedtest request between service worker and backend
+ *
+ * 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<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Serviceworker_Speedtest
+  > {
+  method: 'serviceworker_speedtest';
+  request: {
+    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: {
+    bytesTransferred: number;
+    timestamp: number;
+    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>`;
--- a/ts_swdash/index.ts
+++ b/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';
--- a/ts_swdash/plugins.ts
+++ b/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 };
--- a/ts_swdash/sw-dash-app.ts
+++ b/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>
+    `;
+  }
+}
--- a/ts_swdash/sw-dash-domains.ts
+++ b/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>
+    `;
+  }
+}
--- a/ts_swdash/sw-dash-events.ts
+++ b/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>
+        ` : ''}
+      `}
+    `;
+  }
+}
--- a/ts_swdash/sw-dash-overview.ts
+++ b/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>
+    `;
+  }
+}
--- a/ts_swdash/sw-dash-requests.ts
+++ b/ts_swdash/sw-dash-requests.ts
@@ -0,0 +1,581 @@
+import { LitElement, html, css, property, state, customElement } from './plugins.js';
+import type { CSSResult, TemplateResult } from './plugins.js';
+import { sharedStyles, panelStyles, tableStyles, buttonStyles } from './sw-dash-styles.js';
+
+export interface ITypedRequestLogEntry {
+  correlationId: string;
+  method: string;
+  direction: 'outgoing' | 'incoming';
+  phase: 'request' | 'response';
+  timestamp: number;
+  durationMs?: number;
+  payload: any;
+  error?: string;
+}
+
+export interface ITypedRequestStats {
+  totalRequests: number;
+  totalResponses: number;
+  methodCounts: Record<string, { requests: number; responses: number; errors: number; avgDurationMs: number }>;
+  errorCount: number;
+  avgDurationMs: number;
+}
+
+type TRequestFilter = 'all' | 'outgoing' | 'incoming';
+type TPhaseFilter = 'all' | 'request' | 'response';
+
+/**
+ * TypedRequest traffic monitoring panel for sw-dash
+ *
+ * Receives logs, stats, and methods via properties from parent (sw-dash-app).
+ * Filtering is done locally.
+ * Load more and clear operations dispatch events to parent.
+ */
+@customElement('sw-dash-requests')
+export class SwDashRequests extends LitElement {
+  public static styles: CSSResult[] = [
+    sharedStyles,
+    panelStyles,
+    tableStyles,
+    buttonStyles,
+    css`
+      :host {
+        display: block;
+      }
+
+      .requests-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: var(--space-4);
+        gap: var(--space-3);
+        flex-wrap: wrap;
+      }
+
+      .filter-group {
+        display: flex;
+        align-items: center;
+        gap: var(--space-2);
+      }
+
+      .filter-label {
+        font-size: 12px;
+        color: var(--text-tertiary);
+      }
+
+      .filter-select {
+        background: var(--bg-secondary);
+        border: 1px solid var(--border-default);
+        border-radius: var(--radius-sm);
+        padding: var(--space-1) var(--space-2);
+        color: var(--text-primary);
+        font-size: 12px;
+      }
+
+      .filter-select:focus {
+        outline: none;
+        border-color: var(--accent-primary);
+      }
+
+      .requests-list {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-2);
+        max-height: 600px;
+        overflow-y: auto;
+      }
+
+      .request-card {
+        background: var(--bg-secondary);
+        border: 1px solid var(--border-default);
+        border-radius: var(--radius-md);
+        padding: var(--space-3);
+      }
+
+      .request-card.has-error {
+        border-color: var(--accent-error);
+      }
+
+      .request-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: flex-start;
+        margin-bottom: var(--space-2);
+        gap: var(--space-2);
+      }
+
+      .request-badges {
+        display: flex;
+        gap: var(--space-2);
+        align-items: center;
+        flex-wrap: wrap;
+      }
+
+      .badge {
+        display: inline-flex;
+        align-items: center;
+        padding: var(--space-1) var(--space-2);
+        border-radius: var(--radius-sm);
+        font-size: 11px;
+        font-weight: 500;
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+      }
+
+      .badge.direction-outgoing { background: rgba(59, 130, 246, 0.15); color: #3b82f6; }
+      .badge.direction-incoming { background: rgba(34, 197, 94, 0.15); color: var(--accent-success); }
+      .badge.phase-request { background: rgba(251, 191, 36, 0.15); color: var(--accent-warning); }
+      .badge.phase-response { background: rgba(99, 102, 241, 0.15); color: var(--accent-primary); }
+      .badge.error { background: rgba(239, 68, 68, 0.15); color: var(--accent-error); }
+
+      .method-name {
+        font-size: 13px;
+        font-weight: 600;
+        color: var(--text-primary);
+        font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+      }
+
+      .request-meta {
+        display: flex;
+        gap: var(--space-3);
+        align-items: center;
+        font-size: 11px;
+        color: var(--text-tertiary);
+      }
+
+      .request-time {
+        font-variant-numeric: tabular-nums;
+      }
+
+      .request-duration {
+        color: var(--accent-success);
+      }
+
+      .request-duration.slow {
+        color: var(--accent-warning);
+      }
+
+      .request-duration.very-slow {
+        color: var(--accent-error);
+      }
+
+      .request-payload {
+        font-size: 11px;
+        color: var(--text-tertiary);
+        background: var(--bg-tertiary);
+        padding: var(--space-2);
+        border-radius: var(--radius-sm);
+        font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+        white-space: pre-wrap;
+        word-break: break-all;
+        max-height: 150px;
+        overflow-y: auto;
+        margin-top: var(--space-2);
+      }
+
+      .request-error {
+        font-size: 12px;
+        color: var(--accent-error);
+        background: rgba(239, 68, 68, 0.1);
+        padding: var(--space-2);
+        border-radius: var(--radius-sm);
+        margin-top: var(--space-2);
+      }
+
+      .stats-bar {
+        display: flex;
+        gap: var(--space-4);
+        margin-bottom: var(--space-4);
+        padding: var(--space-3);
+        background: var(--bg-secondary);
+        border-radius: var(--radius-md);
+        border: 1px solid var(--border-default);
+        flex-wrap: wrap;
+      }
+
+      .stat-item {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-1);
+      }
+
+      .stat-value {
+        font-size: 18px;
+        font-weight: 600;
+        color: var(--text-primary);
+        font-variant-numeric: tabular-nums;
+      }
+
+      .stat-value.error {
+        color: var(--accent-error);
+      }
+
+      .stat-label {
+        font-size: 11px;
+        color: var(--text-tertiary);
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+      }
+
+      .method-stats {
+        margin-bottom: var(--space-4);
+      }
+
+      .method-stats-title {
+        font-size: 12px;
+        font-weight: 500;
+        color: var(--text-secondary);
+        margin-bottom: var(--space-2);
+      }
+
+      .method-stats-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+        gap: var(--space-2);
+      }
+
+      .method-stat-card {
+        background: var(--bg-tertiary);
+        border-radius: var(--radius-sm);
+        padding: var(--space-2);
+      }
+
+      .method-stat-name {
+        font-size: 11px;
+        font-weight: 500;
+        color: var(--text-primary);
+        font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+        margin-bottom: var(--space-1);
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .method-stat-details {
+        display: flex;
+        gap: var(--space-3);
+        font-size: 10px;
+        color: var(--text-tertiary);
+      }
+
+      .empty-state {
+        text-align: center;
+        padding: var(--space-6);
+        color: var(--text-tertiary);
+      }
+
+      .clear-btn {
+        background: rgba(239, 68, 68, 0.1);
+        color: var(--accent-error);
+        border: 1px solid transparent;
+      }
+
+      .clear-btn:hover {
+        background: rgba(239, 68, 68, 0.2);
+        border-color: var(--accent-error);
+      }
+
+      .pagination {
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        gap: var(--space-2);
+        margin-top: var(--space-4);
+      }
+
+      .page-info {
+        font-size: 12px;
+        color: var(--text-tertiary);
+      }
+
+      .toggle-payload {
+        font-size: 11px;
+        color: var(--accent-primary);
+        cursor: pointer;
+        margin-top: var(--space-1);
+      }
+
+      .toggle-payload:hover {
+        text-decoration: underline;
+      }
+
+      .correlation-id {
+        font-size: 10px;
+        color: var(--text-tertiary);
+        font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+      }
+    `
+  ];
+
+  // Received from parent (sw-dash-app)
+  @property({ type: Array }) accessor logs: ITypedRequestLogEntry[] = [];
+  @property({ type: Number }) accessor totalCount = 0;
+  @property({ type: Object }) accessor stats: ITypedRequestStats | null = null;
+  @property({ type: Array }) accessor methods: string[] = [];
+
+  // Local state for filtering
+  @state() accessor directionFilter: TRequestFilter = 'all';
+  @state() accessor phaseFilter: TPhaseFilter = 'all';
+  @state() accessor methodFilter = '';
+  @state() accessor searchText = '';
+  @state() accessor expandedPayloads: Set<string> = new Set();
+  @state() accessor isLoadingMore = false;
+
+  private handleDirectionFilterChange(e: Event): void {
+    this.directionFilter = (e.target as HTMLSelectElement).value as TRequestFilter;
+    // Local filtering - no HTTP request
+  }
+
+  private handlePhaseFilterChange(e: Event): void {
+    this.phaseFilter = (e.target as HTMLSelectElement).value as TPhaseFilter;
+    // Local filtering - no HTTP request
+  }
+
+  private handleMethodFilterChange(e: Event): void {
+    this.methodFilter = (e.target as HTMLSelectElement).value;
+    // Local filtering - no HTTP request
+  }
+
+  private handleSearch(e: Event): void {
+    this.searchText = (e.target as HTMLInputElement).value.toLowerCase();
+  }
+
+  private handleClear(): void {
+    if (!confirm('Are you sure you want to clear the request logs? This cannot be undone.')) {
+      return;
+    }
+    // Dispatch event to parent to clear via DeesComms
+    this.dispatchEvent(new CustomEvent('clear-requests', {
+      bubbles: true,
+      composed: true,
+    }));
+  }
+
+  private loadMore(): void {
+    if (this.isLoadingMore || this.logs.length === 0) return;
+
+    this.isLoadingMore = true;
+    const oldestLog = this.logs[this.logs.length - 1];
+
+    // Dispatch event to parent to load more via DeesComms
+    this.dispatchEvent(new CustomEvent('load-more-requests', {
+      detail: {
+        before: oldestLog.timestamp,
+        method: this.methodFilter || undefined,
+      },
+      bubbles: true,
+      composed: true,
+    }));
+
+    // Reset loading state after a short delay (parent will update logs prop)
+    setTimeout(() => {
+      this.isLoadingMore = false;
+    }, 1000);
+  }
+
+  private togglePayload(correlationId: string): void {
+    const newSet = new Set(this.expandedPayloads);
+    if (newSet.has(correlationId)) {
+      newSet.delete(correlationId);
+    } else {
+      newSet.add(correlationId);
+    }
+    this.expandedPayloads = newSet;
+  }
+
+  private formatTimestamp(ts: number): string {
+    const date = new Date(ts);
+    return date.toLocaleTimeString(undefined, {
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      fractionalSecondDigits: 3
+    });
+  }
+
+  private getDurationClass(durationMs: number | undefined): string {
+    if (!durationMs) return '';
+    if (durationMs > 5000) return 'very-slow';
+    if (durationMs > 1000) return 'slow';
+    return '';
+  }
+
+  private formatDuration(durationMs: number | undefined): string {
+    if (!durationMs) return '';
+    if (durationMs < 1000) return `${durationMs}ms`;
+    return `${(durationMs / 1000).toFixed(2)}s`;
+  }
+
+  /**
+   * Filter logs locally based on direction, phase, method, and search text
+   */
+  private getFilteredLogs(): ITypedRequestLogEntry[] {
+    let result = this.logs;
+
+    // Apply direction filter
+    if (this.directionFilter !== 'all') {
+      result = result.filter(l => l.direction === this.directionFilter);
+    }
+
+    // Apply phase filter
+    if (this.phaseFilter !== 'all') {
+      result = result.filter(l => l.phase === this.phaseFilter);
+    }
+
+    // Apply method filter
+    if (this.methodFilter) {
+      result = result.filter(l => l.method === this.methodFilter);
+    }
+
+    // Apply search
+    if (this.searchText) {
+      result = result.filter(l =>
+        l.method.toLowerCase().includes(this.searchText) ||
+        l.correlationId.toLowerCase().includes(this.searchText) ||
+        (l.error && l.error.toLowerCase().includes(this.searchText)) ||
+        JSON.stringify(l.payload).toLowerCase().includes(this.searchText)
+      );
+    }
+
+    return result;
+  }
+
+  public render(): TemplateResult {
+    const filteredLogs = this.getFilteredLogs();
+
+    return html`
+      <!-- Stats Bar -->
+      <div class="stats-bar">
+        <div class="stat-item">
+          <span class="stat-value">${this.stats?.totalRequests ?? 0}</span>
+          <span class="stat-label">Total Requests</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">${this.stats?.totalResponses ?? 0}</span>
+          <span class="stat-label">Total Responses</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value ${(this.stats?.errorCount ?? 0) > 0 ? 'error' : ''}">${this.stats?.errorCount ?? 0}</span>
+          <span class="stat-label">Errors</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">${this.stats?.avgDurationMs ?? 0}ms</span>
+          <span class="stat-label">Avg Duration</span>
+        </div>
+        <div class="stat-item">
+          <span class="stat-value">${filteredLogs.length}</span>
+          <span class="stat-label">Showing</span>
+        </div>
+      </div>
+
+      <!-- Method Stats -->
+      ${this.stats && Object.keys(this.stats.methodCounts).length > 0 ? html`
+        <div class="method-stats">
+          <div class="method-stats-title">Methods</div>
+          <div class="method-stats-grid">
+            ${Object.entries(this.stats.methodCounts).slice(0, 8).map(([method, data]) => html`
+              <div class="method-stat-card">
+                <div class="method-stat-name" title="${method}">${method}</div>
+                <div class="method-stat-details">
+                  <span>${data.requests} req</span>
+                  <span>${data.responses} res</span>
+                  ${data.errors > 0 ? html`<span style="color: var(--accent-error)">${data.errors} err</span>` : ''}
+                  <span>${data.avgDurationMs}ms avg</span>
+                </div>
+              </div>
+            `)}
+          </div>
+        </div>
+      ` : ''}
+
+      <!-- Filters -->
+      <div class="requests-header">
+        <div class="filter-group">
+          <span class="filter-label">Direction:</span>
+          <select class="filter-select" @change="${this.handleDirectionFilterChange}">
+            <option value="all">All</option>
+            <option value="outgoing">Outgoing</option>
+            <option value="incoming">Incoming</option>
+          </select>
+
+          <span class="filter-label">Phase:</span>
+          <select class="filter-select" @change="${this.handlePhaseFilterChange}">
+            <option value="all">All</option>
+            <option value="request">Request</option>
+            <option value="response">Response</option>
+          </select>
+
+          <span class="filter-label">Method:</span>
+          <select class="filter-select" @change="${this.handleMethodFilterChange}">
+            <option value="">All Methods</option>
+            ${this.methods.map(m => html`<option value="${m}">${m}</option>`)}
+          </select>
+
+          <input
+            type="text"
+            class="search-input"
+            placeholder="Search..."
+            .value="${this.searchText}"
+            @input="${this.handleSearch}"
+            style="width: 150px;"
+          >
+        </div>
+        <button class="btn clear-btn" @click="${this.handleClear}">Clear Logs</button>
+      </div>
+
+      <!-- Request List -->
+      ${this.logs.length === 0 ? html`
+        <div class="empty-state">No request logs found. Traffic will appear here as TypedRequests are made.</div>
+      ` : filteredLogs.length === 0 ? html`
+        <div class="empty-state">No logs match filter</div>
+      ` : html`
+        <div class="requests-list">
+          ${filteredLogs.map(log => html`
+            <div class="request-card ${log.error ? 'has-error' : ''}">
+              <div class="request-header">
+                <div>
+                  <div class="request-badges">
+                    <span class="badge direction-${log.direction}">${log.direction}</span>
+                    <span class="badge phase-${log.phase}">${log.phase}</span>
+                    ${log.error ? html`<span class="badge error">error</span>` : ''}
+                  </div>
+                  <div class="method-name">${log.method}</div>
+                  <div class="correlation-id">${log.correlationId}</div>
+                </div>
+                <div class="request-meta">
+                  <span class="request-time">${this.formatTimestamp(log.timestamp)}</span>
+                  ${log.durationMs !== undefined ? html`
+                    <span class="request-duration ${this.getDurationClass(log.durationMs)}">
+                      ${this.formatDuration(log.durationMs)}
+                    </span>
+                  ` : ''}
+                </div>
+              </div>
+
+              ${log.error ? html`
+                <div class="request-error">${log.error}</div>
+              ` : ''}
+
+              <div class="toggle-payload" @click="${() => this.togglePayload(log.correlationId)}">
+                ${this.expandedPayloads.has(log.correlationId) ? 'Hide payload' : 'Show payload'}
+              </div>
+
+              ${this.expandedPayloads.has(log.correlationId) ? html`
+                <div class="request-payload">${JSON.stringify(log.payload, null, 2)}</div>
+              ` : ''}
+            </div>
+          `)}
+        </div>
+
+        ${this.logs.length < this.totalCount ? html`
+          <div class="pagination">
+            <button class="btn btn-secondary" @click="${this.loadMore}" ?disabled="${this.isLoadingMore}">
+              ${this.isLoadingMore ? 'Loading...' : 'Load More'}
+            </button>
+            <span class="page-info">${this.logs.length} of ${this.totalCount} logs</span>
+          </div>
+        ` : ''}
+      `}
+    `;
+  }
+}
--- a/ts_swdash/sw-dash-styles.ts
+++ b/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;
+  }
+`;
--- a/ts_swdash/sw-dash-table.ts
+++ b/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>
+    `;
+  }
+}
--- a/ts_swdash/sw-dash-types.ts
+++ b/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>
+    `;
+  }
+}
--- a/ts_swdash/sw-dash-urls.ts
+++ b/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>
+    `;
+  }
+}
--- a/ts_web_inject/index.ts
+++ b/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,23 +161,42 @@ 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) {
+        // Fallback: clear caches via Cache API when service worker client isn't initialized
+        try {
+          const cacheKeys = await caches.keys();
+          await Promise.all(cacheKeys.map(key => caches.delete(key)));
+          logger.log('ok', 'Cleared caches via Cache API fallback');
+        } catch (err) {
+          logger.log('warn', `Failed to clear caches via Cache API: ${err}`);
+        }
      } else {
-        console.log('globalThis.globalSw not found...');
+        console.log('globalThis.globalSw not found and Cache API not available...');
      }
-      this.infoscreen.setText(`cleaned caches`);
+
+      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;
    }
  }
@@ -102,19 +213,27 @@ export class ReloadChecker {
        this.typedrouter,
        plugins.typedsocket.TypedSocket.useWindowLocationOriginUrl()
      );
-      this.typedsocket.addTag('typedserver_frontend', {});
-      this.typedsocket.eventSubject.subscribe(async (eventArg) => {
-        console.log(`typedsocket event subscription: ${eventArg}`);
-        if (
-          eventArg === 'disconnected' ||
-          eventArg === 'disconnecting' ||
-          eventArg === 'timedOut'
-        ) {
+      await this.typedsocket.setTag('typedserver_frontend', {});
+      this.typedsocket.statusSubject.subscribe(async (statusArg) => {
+        console.log(`typedsocket status: ${statusArg}`);
+        if (statusArg === 'disconnected' || statusArg === 'reconnecting') {
          this.backendConnectionLost = true;
-          this.infoscreen.setText(`typedsocket ${eventArg}!`);
-        } else if (eventArg === 'connected' && this.backendConnectionLost) {
+          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>(
@@ -125,6 +244,9 @@ export class ReloadChecker {
        }
      });
      logger.log('success', `ReloadChecker connected through typedsocket!`);
+
+      // Enable traffic logging for sw-dash
+      this.enableTrafficLogging();
    }
  }

@@ -132,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();
@@ -145,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');
  }
 }

--- a/ts_web_inject/typedserver_web.infoscreen.ts
+++ b/ts_web_inject/typedserver_web.infoscreen.ts
@@ -14,10 +14,10 @@ export class TypedserverInfoscreen extends LitElement {
  //INSTANCE

  @property()
-  private text = 'Hello';
+  accessor text = 'Hello';

  @property()
-  private success = false;
+  accessor success = false;

  public static styles = [
    css`
--- a/ts_web_inject/typedserver_web.statuspill.ts
+++ b/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>
+    `;
+  }
+}
--- a/ts_web_serviceworker/classes.backend.ts
+++ b/ts_web_serviceworker/classes.backend.ts
@@ -1,6 +1,10 @@
 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 {
@@ -41,11 +45,36 @@ declare global {
 */
 export class ServiceworkerBackend {
  public deesComms = new plugins.deesComms.DeesComms();
+  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']>;
  }) {
+    this.swSelf = optionsArg.self as unknown as ServiceWorkerGlobalScope;
+    const metrics = getMetricsCollector();

    // lets handle wakestuff
    optionsArg.self.addEventListener('message', (event) => {
@@ -53,16 +82,271 @@ export class ServiceworkerBackend {
        console.log('sw-backend: got wake up call');
      }
    });
+
    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_Client_Serviceworker_ConnectionPolling>('broadcastConnectionPolling', async reqArg => {
+      // Record connection attempt
+      metrics.recordConnectionAttempt();
+      metrics.recordConnectionSuccess();
+      // Update connected clients count
+      await this.updateConnectedClientsCount();
      return {
        serviceworkerId: '123'
      };
-    })
+    });

    this.deesComms.createTypedHandler<interfaces.serviceworker.IRequest_PurgeServiceWorkerCache>('purgeServiceWorkerCache', async reqArg => {
      console.log(`Executing purge cache in serviceworker backend.`)
      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}`);
+    }
+  }
+
+  /**
+   * Start periodic updates of connected client count
+   */
+  private startClientCountUpdates(): void {
+    // Update immediately
+    this.updateConnectedClientsCount();
+
+    // Then update every 5 seconds
+    this.clientUpdateInterval = setInterval(() => {
+      this.updateConnectedClientsCount();
+    }, 5000);
+  }
+
+  /**
+   * Update the connected clients count using the Clients API
+   */
+  private async updateConnectedClientsCount(): Promise<void> {
+    try {
+      const clients = await this.swSelf.clients.matchAll({ type: 'window' });
+      const metrics = getMetricsCollector();
+      metrics.setConnectedClients(clients.length);
+    } catch (error) {
+      logger.log('warn', `Failed to update connected clients count: ${error}`);
+    }
  }

  /**
@@ -71,21 +355,19 @@ export class ServiceworkerBackend {
  public async triggerReloadAll() {
    try {
      logger.log('info', 'Triggering reload for all clients due to new version');
-      
+
      // Send update message via DeesComms
      // This will be picked up by clients that have registered a handler for 'serviceworker_newVersion'
-      await this.deesComms.postMessage({
-        method: 'serviceworker_newVersion',
-        request: {},
-        messageId: `sw_update_${Date.now()}`
-      });
-      
+      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
-      // We need to type-cast self since TypeScript doesn't recognize ServiceWorker API
-      const swSelf = self as unknown as ServiceWorkerGlobalScope;
-      const clients = await swSelf.clients.matchAll({ type: 'window' });
+      const clients = await this.swSelf.clients.matchAll({ type: 'window' });
      logger.log('info', `Found ${clients.length} clients to reload`);
-      
+
+      // Update metrics with current client count
+      const metrics = getMetricsCollector();
+      metrics.setConnectedClients(clients.length);
+
      for (const client of clients) {
        if ('navigate' in client) {
          // For modern browsers, navigate to the same URL to trigger reload
@@ -139,17 +421,101 @@ export class ServiceworkerBackend {
      title: 'Alert',
      body: alertText
    });
-    
+
    // Send message to clients who might be able to show an actual alert
    try {
-      await this.deesComms.postMessage({
-        method: 'serviceworker_alert',
-        request: { message: alertText },
-        messageId: `sw_alert_${Date.now()}`
-      });
+      await this.deesComms.postMessage(this.createMessage('serviceworker_alert', { message: alertText }));
      logger.log('info', `Alert message sent to clients: ${alertText}`);
    } catch (error) {
      logger.log('error', `Failed to send alert to clients: ${error instanceof Error ? error.message : String(error)}`);
    }
  }
+
+  // ===============
+  // Push methods for real-time updates
+  // ===============
+
+  /**
+   * Pushes a new event log entry to all connected clients
+   * Called immediately when an event is logged
+   */
+  public async pushEvent(entry: interfaces.serviceworker.IEventLogEntry): Promise<void> {
+    try {
+      await this.deesComms.postMessage(this.createMessage('serviceworker_eventLogged', entry));
+      logger.log('note', `Pushed event to clients: ${entry.type}`);
+    } catch (error) {
+      logger.log('warn', `Failed to push event: ${error}`);
+    }
+  }
+
+  /**
+   * Pushes a metrics update to all connected clients
+   * Throttled to max 1 update per 500ms to prevent spam
+   */
+  public pushMetricsUpdate(): void {
+    // Mark that we have a pending update
+    this.pendingMetricsUpdate = true;
+
+    // If we're already throttling, just wait for the next window
+    if (this.metricsUpdateThrottle) {
+      return;
+    }
+
+    // Send the update and start throttle window
+    this.sendMetricsUpdate();
+
+    this.metricsUpdateThrottle = setTimeout(() => {
+      this.metricsUpdateThrottle = null;
+      // If there was a pending update during the throttle window, send it now
+      if (this.pendingMetricsUpdate) {
+        this.sendMetricsUpdate();
+      }
+    }, this.METRICS_THROTTLE_MS);
+  }
+
+  /**
+   * Actually sends the metrics update via DeesComms
+   */
+  private async sendMetricsUpdate(): Promise<void> {
+    this.pendingMetricsUpdate = false;
+    const metrics = getMetricsCollector();
+    const metricsData = metrics.getMetrics();
+
+    const snapshot: interfaces.serviceworker.IMetricsSnapshot = {
+      cache: {
+        hits: metricsData.cache.hits,
+        misses: metricsData.cache.misses,
+        errors: metricsData.cache.errors,
+        bytesServedFromCache: metricsData.cache.bytesServedFromCache,
+        bytesFetched: metricsData.cache.bytesFetched,
+      },
+      network: {
+        totalRequests: metricsData.network.totalRequests,
+        successfulRequests: metricsData.network.successfulRequests,
+        failedRequests: metricsData.network.failedRequests,
+      },
+      cacheHitRate: metrics.getCacheHitRate(),
+      networkSuccessRate: metrics.getNetworkSuccessRate(),
+      resourceCount: metrics.getResourceCount(),
+      uptime: metricsData.uptime,
+      timestamp: Date.now(),
+    };
+
+    try {
+      await this.deesComms.postMessage(this.createMessage('serviceworker_metricsUpdate', snapshot));
+    } catch (error) {
+      logger.log('warn', `Failed to push metrics update: ${error}`);
+    }
+  }
+
+  /**
+   * Pushes notification when a resource is cached
+   */
+  public async pushResourceCached(url: string, contentType: string, size: number, cached: boolean): Promise<void> {
+    try {
+      await this.deesComms.postMessage(this.createMessage('serviceworker_resourceCached', { url, contentType, size, cached }));
+    } catch (error) {
+      logger.log('warn', `Failed to push resource cached: ${error}`);
+    }
+  }
 }
--- a/ts_web_serviceworker/classes.cachemanager.ts
+++ b/ts_web_serviceworker/classes.cachemanager.ts
@@ -2,6 +2,10 @@ import * as plugins from './plugins.js';
 import * as interfaces from './env.js';
 import { logger } from './logging.js';
 import { ServiceWorker } from './classes.serviceworker.js';
+import { getMetricsCollector } from './classes.metrics.js';
+import { getEventBus, ServiceWorkerEvent } from './classes.eventbus.js';
+import { getErrorHandler, ServiceWorkerErrorType } from './classes.errorhandler.js';
+import { getDashboardGenerator } from './classes.dashboard.js';

 export class CacheManager {
  public losslessServiceWorkerRef: ServiceWorker;
@@ -10,9 +14,113 @@ export class CacheManager {
    runtimeCacheName: 'runtime'
  };

+  // Request deduplication: tracks in-flight requests to prevent duplicate fetches
+  private inFlightRequests: Map<string, Promise<Response>> = new Map();
+  private readonly INFLIGHT_CLEANUP_INTERVAL = 30000; // 30 seconds
+  private cleanupIntervalId: ReturnType<typeof setInterval> | null = null;
+
  constructor(losslessServiceWorkerRefArg: ServiceWorker) {
    this.losslessServiceWorkerRef = losslessServiceWorkerRefArg;
    this._setupCache();
+    this._setupInFlightCleanup();
+  }
+
+  /**
+   * Sets up periodic cleanup of stale in-flight request entries
+   */
+  private _setupInFlightCleanup(): void {
+    // Clean up stale entries periodically
+    this.cleanupIntervalId = setInterval(() => {
+      // The Map should naturally clean up via .finally(), but this is a safety net
+      if (this.inFlightRequests.size > 100) {
+        logger.log('warn', `In-flight requests map has ${this.inFlightRequests.size} entries, clearing...`);
+        this.inFlightRequests.clear();
+      }
+    }, this.INFLIGHT_CLEANUP_INTERVAL);
+  }
+
+  /**
+   * Fetches a request with deduplication - coalesces identical concurrent requests
+   */
+  private async fetchWithDeduplication(request: Request): Promise<Response> {
+    const key = `${request.method}:${request.url}`;
+    const metrics = getMetricsCollector();
+    const eventBus = getEventBus();
+
+    // Check if we already have an in-flight request for this URL
+    const existingRequest = this.inFlightRequests.get(key);
+    if (existingRequest) {
+      logger.log('note', `Deduplicating request for ${request.url}`);
+      try {
+        const response = await existingRequest;
+        // Clone the response since it may have been consumed
+        return response.clone();
+      } catch (error) {
+        // If the original request failed, we should try again
+        this.inFlightRequests.delete(key);
+        throw error;
+      }
+    }
+
+    // Record the new request
+    metrics.recordRequest(request.url);
+    eventBus.emit(ServiceWorkerEvent.NETWORK_REQUEST_START, {
+      url: request.url,
+      method: request.method,
+    });
+
+    const startTime = Date.now();
+
+    // Create a new fetch promise and track it
+    const fetchPromise = fetch(request)
+      .then(async (response) => {
+        const duration = Date.now() - startTime;
+
+        // Try to get response size
+        const contentLength = response.headers.get('content-length');
+        const bytes = contentLength ? parseInt(contentLength, 10) : 0;
+
+        metrics.recordRequestSuccess(request.url, duration, bytes);
+        eventBus.emit(ServiceWorkerEvent.NETWORK_REQUEST_COMPLETE, {
+          url: request.url,
+          method: request.method,
+          status: response.status,
+          duration,
+          bytes,
+        });
+
+        return response;
+      })
+      .catch((error) => {
+        const duration = Date.now() - startTime;
+        const errorHandler = getErrorHandler();
+
+        errorHandler.handleNetworkError(
+          `Fetch failed for ${request.url}: ${error?.message || error}`,
+          request.url,
+          error instanceof Error ? error : undefined,
+          { method: request.method, duration }
+        );
+
+        metrics.recordRequestFailure(request.url, error?.message);
+        eventBus.emit(ServiceWorkerEvent.NETWORK_REQUEST_ERROR, {
+          url: request.url,
+          method: request.method,
+          duration,
+          error: error?.message || 'Unknown error',
+        });
+
+        throw error;
+      })
+      .finally(() => {
+        // Remove from in-flight requests when done
+        this.inFlightRequests.delete(key);
+      });
+
+    // Track the in-flight request
+    this.inFlightRequests.set(key, fetchPromise);
+
+    return fetchPromise;
  }

  /**
@@ -96,6 +204,34 @@ export class CacheManager {
        const originalRequest: Request = fetchEventArg.request;
        const parsedUrl = new URL(originalRequest.url);

+        // Handle dashboard routes - serve directly from service worker
+        if (parsedUrl.pathname === '/sw-dash' || parsedUrl.pathname === '/sw-dash/') {
+          const dashboard = getDashboardGenerator();
+          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(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 (
          parsedUrl.hostname.includes('paddle.com') ||
@@ -128,16 +264,32 @@ export class CacheManager {

          const matchRequest = createMatchRequest(originalRequest);
          const cachedResponse = await caches.match(matchRequest);
+          const metrics = getMetricsCollector();
+          const eventBus = getEventBus();
+
          if (cachedResponse) {
+            // 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}`);
            done.resolve(cachedResponse);
            return;
          }

+          // Record cache miss
+          metrics.recordCacheMiss(matchRequest.url);
+          eventBus.emitCacheMiss(matchRequest.url);
+
          logger.log('info', `NOTYETCACHED: Trying to cache ${matchRequest.url}`);
          let newResponse: Response;
          try {
-            newResponse = await fetch(matchRequest);
+            // Use deduplicated fetch to prevent concurrent requests for the same resource
+            newResponse = await this.fetchWithDeduplication(matchRequest);
          } catch (err: any) {
            logger.log('error', `Fetch error for ${matchRequest.url}: ${err}`);
            newResponse = await create500Response(matchRequest, new Response(err.message));
@@ -196,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) {
--- a/ts_web_serviceworker/classes.config.ts
+++ b/ts_web_serviceworker/classes.config.ts
@@ -0,0 +1,232 @@
+import * as plugins from './plugins.js';
+
+/**
+ * Configuration interface for service worker settings
+ */
+export interface IServiceWorkerConfig {
+  // Cache settings
+  cache: {
+    maxAge: number;           // Maximum cache age in milliseconds (default: 24 hours)
+    offlineGracePeriod: number; // Grace period when offline (default: 7 days)
+    runtimeCacheName: string;   // Name of the runtime cache
+  };
+
+  // Update check settings
+  update: {
+    minCheckInterval: number;   // Minimum interval between update checks (default: 100 seconds)
+    debounceTime: number;       // Debounce time for update tasks (default: 2000ms)
+    revalidationDebounce: number; // Debounce time for revalidation (default: 6000ms)
+  };
+
+  // Network settings
+  network: {
+    requestTimeout: number;     // Default request timeout (default: 5000ms)
+    maxRetries: number;         // Maximum retry attempts (default: 3)
+    retryDelay: number;         // Delay between retries (default: 1000ms)
+  };
+
+  // Blocked domains - requests to these domains bypass the service worker
+  blockedDomains: string[];
+
+  // Blocked paths - requests with these path prefixes bypass the service worker
+  blockedPaths: string[];
+
+  // External cacheable domains - external domains that should be cached
+  cacheableDomains: string[];
+}
+
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG: IServiceWorkerConfig = {
+  cache: {
+    maxAge: 24 * 60 * 60 * 1000, // 24 hours
+    offlineGracePeriod: 7 * 24 * 60 * 60 * 1000, // 7 days
+    runtimeCacheName: 'runtime',
+  },
+  update: {
+    minCheckInterval: 100000, // 100 seconds
+    debounceTime: 2000,
+    revalidationDebounce: 6000,
+  },
+  network: {
+    requestTimeout: 5000,
+    maxRetries: 3,
+    retryDelay: 1000,
+  },
+  blockedDomains: [
+    'paddle.com',
+    'paypal.com',
+    'reception.lossless.one',
+    'umami.',
+  ],
+  blockedPaths: [
+    '/socket.io',
+    '/api/',
+    'smartserve/reloadcheck',
+  ],
+  cacheableDomains: [
+    'assetbroker.',
+    'unpkg.com',
+    'fonts.googleapis.com',
+    'fonts.gstatic.com',
+  ],
+};
+
+/**
+ * ServiceWorkerConfig manages the configuration for the service worker.
+ * Configuration is persisted to WebStore and can be updated at runtime.
+ */
+export class ServiceWorkerConfig {
+  private static readonly STORE_KEY = 'sw_config';
+  private config: IServiceWorkerConfig;
+  private store: plugins.webstore.WebStore;
+
+  constructor(store: plugins.webstore.WebStore) {
+    this.store = store;
+    this.config = { ...DEFAULT_CONFIG };
+  }
+
+  /**
+   * Loads configuration from WebStore, falling back to defaults
+   */
+  public async load(): Promise<void> {
+    try {
+      if (await this.store.check(ServiceWorkerConfig.STORE_KEY)) {
+        const storedConfig = await this.store.get(ServiceWorkerConfig.STORE_KEY);
+        this.config = this.mergeConfig(DEFAULT_CONFIG, storedConfig);
+      }
+    } catch (error) {
+      console.warn('Failed to load service worker config, using defaults:', error);
+      this.config = { ...DEFAULT_CONFIG };
+    }
+  }
+
+  /**
+   * Saves current configuration to WebStore
+   */
+  public async save(): Promise<void> {
+    await this.store.set(ServiceWorkerConfig.STORE_KEY, this.config);
+  }
+
+  /**
+   * Gets the current configuration
+   */
+  public get(): IServiceWorkerConfig {
+    return this.config;
+  }
+
+  /**
+   * Updates configuration with partial values
+   */
+  public async update(partialConfig: Partial<IServiceWorkerConfig>): Promise<void> {
+    this.config = this.mergeConfig(this.config, partialConfig);
+    await this.save();
+  }
+
+  /**
+   * Resets configuration to defaults
+   */
+  public async reset(): Promise<void> {
+    this.config = { ...DEFAULT_CONFIG };
+    await this.save();
+  }
+
+  // Getters for common configuration values
+  public get cacheMaxAge(): number {
+    return this.config.cache.maxAge;
+  }
+
+  public get offlineGracePeriod(): number {
+    return this.config.cache.offlineGracePeriod;
+  }
+
+  public get runtimeCacheName(): string {
+    return this.config.cache.runtimeCacheName;
+  }
+
+  public get minCheckInterval(): number {
+    return this.config.update.minCheckInterval;
+  }
+
+  public get updateDebounceTime(): number {
+    return this.config.update.debounceTime;
+  }
+
+  public get revalidationDebounce(): number {
+    return this.config.update.revalidationDebounce;
+  }
+
+  public get requestTimeout(): number {
+    return this.config.network.requestTimeout;
+  }
+
+  public get maxRetries(): number {
+    return this.config.network.maxRetries;
+  }
+
+  public get retryDelay(): number {
+    return this.config.network.retryDelay;
+  }
+
+  /**
+   * Checks if a URL should be blocked from service worker handling
+   */
+  public shouldBlockUrl(url: string): boolean {
+    try {
+      const parsedUrl = new URL(url);
+
+      // Check blocked domains
+      for (const domain of this.config.blockedDomains) {
+        if (parsedUrl.hostname.includes(domain)) {
+          return true;
+        }
+      }
+
+      // Check blocked paths
+      for (const path of this.config.blockedPaths) {
+        if (parsedUrl.pathname.includes(path)) {
+          return true;
+        }
+      }
+
+      // Check if URL starts with blocked domain pattern
+      if (url.startsWith('https://umami.')) {
+        return true;
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Checks if an external URL should be cached
+   */
+  public shouldCacheExternalUrl(url: string): boolean {
+    for (const domain of this.config.cacheableDomains) {
+      if (url.includes(domain)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Deep merges two configuration objects
+   */
+  private mergeConfig(
+    base: IServiceWorkerConfig,
+    override: Partial<IServiceWorkerConfig>
+  ): IServiceWorkerConfig {
+    return {
+      cache: { ...base.cache, ...override.cache },
+      update: { ...base.update, ...override.update },
+      network: { ...base.network, ...override.network },
+      blockedDomains: override.blockedDomains ?? base.blockedDomains,
+      blockedPaths: override.blockedPaths ?? base.blockedPaths,
+      cacheableDomains: override.cacheableDomains ?? base.cacheableDomains,
+    };
+  }
+}
--- a/ts_web_serviceworker/classes.dashboard.ts
+++ b/ts_web_serviceworker/classes.dashboard.ts
@@ -0,0 +1,420 @@
+import { getMetricsCollector } from './classes.metrics.js';
+import { getServiceWorkerInstance } from './init.js';
+import { getPersistentStore } from './classes.persistentstore.js';
+import { getRequestLogStore } from './classes.requestlogstore.js';
+import * as interfaces from './env.js';
+import type { serviceworker } from '../dist_ts_interfaces/index.js';
+
+type TEventType = serviceworker.TEventType;
+
+/**
+ * Dashboard generator that creates a terminal-like metrics display
+ * served directly from the service worker as a single-page app
+ */
+export class DashboardGenerator {
+  /**
+   * Serves the dashboard HTML page
+   */
+  public serveDashboard(): Response {
+    return new Response(this.generateDashboardHtml(), {
+      headers: {
+        'Content-Type': 'text/html; charset=utf-8',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Serves the metrics JSON endpoint with ALL initial data
+   * This is the single HTTP seed request that provides:
+   * - Current metrics
+   * - Initial events (last 50)
+   * - Initial request logs (last 50)
+   * - Request stats and methods
+   * - Resource data
+   */
+  public async serveMetrics(): Promise<Response> {
+    try {
+      const metrics = getMetricsCollector();
+      const persistentStore = getPersistentStore();
+      await persistentStore.init();
+      const requestLogStore = getRequestLogStore();
+
+      // Get event data
+      const eventResult = await persistentStore.getEventLog({ limit: 50 });
+      const oneHourAgo = Date.now() - 3600000;
+      const eventCountLastHour = await persistentStore.getEventCount(oneHourAgo);
+
+      // Build comprehensive initial response
+      const data = {
+        // Core metrics
+        ...metrics.getMetrics(),
+        cacheHitRate: metrics.getCacheHitRate(),
+        networkSuccessRate: metrics.getNetworkSuccessRate(),
+        resourceCount: metrics.getResourceCount(),
+        summary: metrics.getSummary(),
+
+        // Resources data
+        resources: metrics.getCachedResources(),
+        domains: metrics.getDomainStats(),
+        contentTypes: metrics.getContentTypeStats(),
+
+        // Events data (initial 50)
+        events: eventResult.events,
+        eventTotalCount: eventResult.totalCount,
+        eventCountLastHour,
+
+        // Request logs data (initial 50)
+        requestLogs: requestLogStore.getEntries({ limit: 50 }),
+        requestTotalCount: requestLogStore.getTotalCount(),
+        requestStats: requestLogStore.getStats(),
+        requestMethods: requestLogStore.getMethods(),
+      };
+
+      return new Response(JSON.stringify(data), {
+        headers: {
+          'Content-Type': 'application/json',
+          'Cache-Control': 'no-store',
+        },
+      });
+    } catch (error) {
+      console.error('[SW Dashboard] serveMetrics error:', error);
+      // Return error response with valid JSON structure so client doesn't crash
+      return new Response(JSON.stringify({
+        error: String(error),
+        cache: { hits: 0, misses: 0, errors: 0, bytesServedFromCache: 0, bytesFetched: 0, averageResponseTime: 0 },
+        network: { totalRequests: 0, successfulRequests: 0, failedRequests: 0, timeouts: 0, averageLatency: 0, totalBytesTransferred: 0 },
+        update: { totalChecks: 0, successfulChecks: 0, failedChecks: 0, updatesFound: 0, updatesApplied: 0, lastCheckTimestamp: 0, lastUpdateTimestamp: 0 },
+        connection: { connectedClients: 0, totalConnectionAttempts: 0, successfulConnections: 0, failedConnections: 0 },
+        speedtest: { lastDownloadSpeedMbps: 0, lastUploadSpeedMbps: 0, lastLatencyMs: 0, lastTestTimestamp: 0, testCount: 0, isOnline: false },
+        startTime: Date.now(),
+        uptime: 0,
+        cacheHitRate: 0,
+        networkSuccessRate: 0,
+        resourceCount: 0,
+        events: [],
+        eventTotalCount: 0,
+        eventCountLastHour: 0,
+        requestLogs: [],
+        requestTotalCount: 0,
+        requestStats: { totalRequests: 0, totalResponses: 0, methodCounts: {}, errorCount: 0, avgDurationMs: 0 },
+        requestMethods: [],
+      }), {
+        headers: {
+          'Content-Type': 'application/json',
+          'Cache-Control': 'no-store',
+        },
+      });
+    }
+  }
+
+  /**
+   * Serves detailed resource data for the SPA views
+   */
+  public serveResources(): Response {
+    return new Response(this.generateResourcesJson(), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Serves event log data
+   */
+  public async serveEventLog(searchParams: URLSearchParams): Promise<Response> {
+    const persistentStore = getPersistentStore();
+    await persistentStore.init();
+
+    const limit = searchParams.get('limit') ? parseInt(searchParams.get('limit')!, 10) : undefined;
+    const type = searchParams.get('type') as TEventType | undefined;
+    const since = searchParams.get('since') ? parseInt(searchParams.get('since')!, 10) : undefined;
+
+    const result = await persistentStore.getEventLog({ limit, type, since });
+
+    return new Response(JSON.stringify(result), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Serves event count since a timestamp
+   */
+  public async serveEventCount(searchParams: URLSearchParams): Promise<Response> {
+    const persistentStore = getPersistentStore();
+    await persistentStore.init();
+
+    const since = searchParams.get('since') ? parseInt(searchParams.get('since')!, 10) : Date.now() - 3600000; // Default: last hour
+
+    const count = await persistentStore.getEventCount(since);
+
+    return new Response(JSON.stringify({ count, since }), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Serves cumulative metrics
+   */
+  public async serveCumulativeMetrics(): Promise<Response> {
+    const persistentStore = getPersistentStore();
+    await persistentStore.init();
+    const metrics = persistentStore.getCumulativeMetrics();
+
+    return new Response(JSON.stringify(metrics), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Clears the event log
+   */
+  public async clearEventLog(): Promise<Response> {
+    const persistentStore = getPersistentStore();
+    await persistentStore.init();
+    const success = await persistentStore.clearEventLog();
+
+    return new Response(JSON.stringify({ success }), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  // ================================
+  // TypedRequest Traffic Endpoints
+  // ================================
+
+  /**
+   * Serves TypedRequest traffic logs
+   */
+  public serveTypedRequestLogs(searchParams: URLSearchParams): Response {
+    const requestLogStore = getRequestLogStore();
+
+    const limit = searchParams.get('limit') ? parseInt(searchParams.get('limit')!, 10) : undefined;
+    const method = searchParams.get('method') || undefined;
+    const since = searchParams.get('since') ? parseInt(searchParams.get('since')!, 10) : undefined;
+
+    const logs = requestLogStore.getEntries({ limit, method, since });
+    const totalCount = requestLogStore.getTotalCount({ method, since });
+
+    return new Response(JSON.stringify({ logs, totalCount }), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Serves TypedRequest traffic statistics
+   */
+  public serveTypedRequestStats(): Response {
+    const requestLogStore = getRequestLogStore();
+    const stats = requestLogStore.getStats();
+
+    return new Response(JSON.stringify(stats), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Clears TypedRequest traffic logs
+   */
+  public clearTypedRequestLogs(): Response {
+    const requestLogStore = getRequestLogStore();
+    requestLogStore.clear();
+
+    return new Response(JSON.stringify({ success: true }), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Serves unique method names from TypedRequest logs
+   */
+  public serveTypedRequestMethods(): Response {
+    const requestLogStore = getRequestLogStore();
+    const methods = requestLogStore.getMethods();
+
+    return new Response(JSON.stringify({ methods }), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  // Speedtest configuration
+  private static readonly TEST_DURATION_MS = 5000;  // 5 seconds per test
+  private static readonly CHUNK_SIZE_KB = 64;       // 64KB chunks
+
+  /**
+   * Runs a time-based speedtest and returns the results
+   * Each test (download/upload) runs for TEST_DURATION_MS, transferring chunks continuously
+   */
+  public async runSpeedtest(): Promise<Response> {
+    const metrics = getMetricsCollector();
+    const persistentStore = getPersistentStore();
+    await persistentStore.init();
+    const results: {
+      latency?: { durationMs: number };
+      download?: { durationMs: number; speedMbps: number; bytesTransferred: number };
+      upload?: { durationMs: number; speedMbps: number; bytesTransferred: number };
+      error?: string;
+      isOnline: boolean;
+    } = { isOnline: false };
+
+    // Log speedtest start
+    await persistentStore.logEvent('speedtest_started', 'Speedtest initiated');
+
+    try {
+      const sw = getServiceWorkerInstance();
+
+      // Check if TypedSocket is connected
+      if (!sw.typedsocket) {
+        results.error = 'TypedSocket not connected';
+        return new Response(JSON.stringify(results), {
+          headers: {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'no-store',
+          },
+        });
+      }
+
+      // Create typed request for speedtest
+      const speedtestRequest = sw.typedsocket.createTypedRequest<
+        interfaces.serviceworker.IRequest_Serviceworker_Speedtest
+      >('serviceworker_speedtest');
+
+      // Latency test - simple ping
+      const latencyStart = Date.now();
+      await speedtestRequest.fire({ type: 'latency' });
+      const latencyDuration = Date.now() - latencyStart;
+      results.latency = { durationMs: latencyDuration };
+      metrics.recordSpeedtest('latency', latencyDuration);
+      results.isOnline = true;
+      metrics.setOnlineStatus(true);
+
+      // Download test - request chunks for TEST_DURATION_MS
+      {
+        const downloadStart = Date.now();
+        let totalBytes = 0;
+        while (Date.now() - downloadStart < DashboardGenerator.TEST_DURATION_MS) {
+          const chunkResult = await speedtestRequest.fire({
+            type: 'download_chunk',
+            chunkSizeKB: DashboardGenerator.CHUNK_SIZE_KB,
+          });
+          totalBytes += chunkResult.bytesTransferred;
+        }
+        const downloadDuration = Date.now() - downloadStart;
+        const downloadSpeedMbps = downloadDuration > 0 ? (totalBytes * 8) / (downloadDuration * 1000) : 0;
+        results.download = { durationMs: downloadDuration, speedMbps: downloadSpeedMbps, bytesTransferred: totalBytes };
+        metrics.recordSpeedtest('download', downloadSpeedMbps);
+      }
+
+      // Upload test - send chunks for TEST_DURATION_MS
+      {
+        const uploadPayload = 'x'.repeat(DashboardGenerator.CHUNK_SIZE_KB * 1024);
+        const uploadStart = Date.now();
+        let totalBytes = 0;
+        while (Date.now() - uploadStart < DashboardGenerator.TEST_DURATION_MS) {
+          const chunkResult = await speedtestRequest.fire({
+            type: 'upload_chunk',
+            payload: uploadPayload,
+          });
+          totalBytes += chunkResult.bytesTransferred;
+        }
+        const uploadDuration = Date.now() - uploadStart;
+        const uploadSpeedMbps = uploadDuration > 0 ? (totalBytes * 8) / (uploadDuration * 1000) : 0;
+        results.upload = { durationMs: uploadDuration, speedMbps: uploadSpeedMbps, bytesTransferred: totalBytes };
+        metrics.recordSpeedtest('upload', uploadSpeedMbps);
+      }
+
+      // Log speedtest completion
+      await persistentStore.logEvent('speedtest_completed', 'Speedtest finished', {
+        downloadMbps: results.download?.speedMbps.toFixed(2),
+        uploadMbps: results.upload?.speedMbps.toFixed(2),
+        latencyMs: results.latency?.durationMs,
+      });
+
+    } catch (error) {
+      results.error = error instanceof Error ? error.message : String(error);
+      results.isOnline = false;
+      metrics.setOnlineStatus(false);
+
+      // Log speedtest failure
+      await persistentStore.logEvent('speedtest_failed', `Speedtest failed: ${results.error}`, {
+        error: results.error,
+      });
+    }
+
+    return new Response(JSON.stringify(results), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+
+  /**
+   * Generates JSON metrics response
+   */
+  public generateMetricsJson(): string {
+    const metrics = getMetricsCollector();
+    return JSON.stringify({
+      ...metrics.getMetrics(),
+      cacheHitRate: metrics.getCacheHitRate(),
+      networkSuccessRate: metrics.getNetworkSuccessRate(),
+      resourceCount: metrics.getResourceCount(),
+      summary: metrics.getSummary(),
+    });
+  }
+
+  /**
+   * Generates JSON response with detailed resource data
+   */
+  public generateResourcesJson(): string {
+    const metrics = getMetricsCollector();
+    return JSON.stringify({
+      resources: metrics.getCachedResources(),
+      domains: metrics.getDomainStats(),
+      contentTypes: metrics.getContentTypeStats(),
+      resourceCount: metrics.getResourceCount(),
+    });
+  }
+
+  /**
+   * Generates a minimal HTML shell that loads the Lit-based dashboard bundle
+   */
+  public generateDashboardHtml(): string {
+    return interfaces.serviceworker.SW_DASH_HTML;
+  }
+
+}
+
+// Export singleton getter
+let dashboardInstance: DashboardGenerator | null = null;
+export const getDashboardGenerator = (): DashboardGenerator => {
+  if (!dashboardInstance) {
+    dashboardInstance = new DashboardGenerator();
+  }
+  return dashboardInstance;
+};
--- a/ts_web_serviceworker/classes.errorhandler.ts
+++ b/ts_web_serviceworker/classes.errorhandler.ts
@@ -0,0 +1,333 @@
+import { logger } from './logging.js';
+
+/**
+ * Error types for categorizing service worker errors
+ */
+export enum ServiceWorkerErrorType {
+  NETWORK = 'NETWORK',
+  CACHE = 'CACHE',
+  UPDATE = 'UPDATE',
+  CONNECTION = 'CONNECTION',
+  TIMEOUT = 'TIMEOUT',
+  UNKNOWN = 'UNKNOWN',
+}
+
+/**
+ * Error severity levels
+ */
+export enum ErrorSeverity {
+  DEBUG = 'debug',
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+  FATAL = 'fatal',
+}
+
+/**
+ * Interface for error context
+ */
+export interface IErrorContext {
+  url?: string;
+  method?: string;
+  statusCode?: number;
+  attempt?: number;
+  maxAttempts?: number;
+  duration?: number;
+  componentName?: string;
+  additionalInfo?: Record<string, unknown>;
+}
+
+/**
+ * Service Worker Error class with type categorization and context
+ */
+export class ServiceWorkerError extends Error {
+  public readonly type: ServiceWorkerErrorType;
+  public readonly severity: ErrorSeverity;
+  public readonly context: IErrorContext;
+  public readonly timestamp: number;
+  public readonly originalError?: Error;
+
+  constructor(
+    message: string,
+    type: ServiceWorkerErrorType = ServiceWorkerErrorType.UNKNOWN,
+    severity: ErrorSeverity = ErrorSeverity.ERROR,
+    context: IErrorContext = {},
+    originalError?: Error
+  ) {
+    super(message);
+    this.name = 'ServiceWorkerError';
+    this.type = type;
+    this.severity = severity;
+    this.context = context;
+    this.timestamp = Date.now();
+    this.originalError = originalError;
+
+    // Maintain proper stack trace in V8 environments
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ServiceWorkerError);
+    }
+  }
+
+  /**
+   * Creates a formatted log message
+   */
+  public toLogMessage(): string {
+    const parts = [
+      `[${this.type}]`,
+      this.message,
+    ];
+
+    if (this.context.url) {
+      parts.push(`URL: ${this.context.url}`);
+    }
+    if (this.context.method) {
+      parts.push(`Method: ${this.context.method}`);
+    }
+    if (this.context.statusCode !== undefined) {
+      parts.push(`Status: ${this.context.statusCode}`);
+    }
+    if (this.context.attempt !== undefined && this.context.maxAttempts !== undefined) {
+      parts.push(`Attempt: ${this.context.attempt}/${this.context.maxAttempts}`);
+    }
+    if (this.context.duration !== undefined) {
+      parts.push(`Duration: ${this.context.duration}ms`);
+    }
+
+    return parts.join(' | ');
+  }
+
+  /**
+   * Converts to a plain object for serialization
+   */
+  public toJSON(): Record<string, unknown> {
+    return {
+      name: this.name,
+      message: this.message,
+      type: this.type,
+      severity: this.severity,
+      context: this.context,
+      timestamp: this.timestamp,
+      stack: this.stack,
+      originalError: this.originalError?.message,
+    };
+  }
+}
+
+/**
+ * Error handler for consistent error handling across service worker components
+ */
+export class ErrorHandler {
+  private static instance: ErrorHandler;
+  private errorHistory: ServiceWorkerError[] = [];
+  private readonly maxHistorySize = 100;
+
+  private constructor() {}
+
+  /**
+   * Gets the singleton instance
+   */
+  public static getInstance(): ErrorHandler {
+    if (!ErrorHandler.instance) {
+      ErrorHandler.instance = new ErrorHandler();
+    }
+    return ErrorHandler.instance;
+  }
+
+  /**
+   * Handles an error with consistent logging and tracking
+   */
+  public handle(
+    error: Error | ServiceWorkerError | string,
+    type: ServiceWorkerErrorType = ServiceWorkerErrorType.UNKNOWN,
+    severity: ErrorSeverity = ErrorSeverity.ERROR,
+    context: IErrorContext = {}
+  ): ServiceWorkerError {
+    let swError: ServiceWorkerError;
+
+    if (error instanceof ServiceWorkerError) {
+      swError = error;
+    } else if (error instanceof Error) {
+      swError = new ServiceWorkerError(error.message, type, severity, context, error);
+    } else {
+      swError = new ServiceWorkerError(String(error), type, severity, context);
+    }
+
+    // Log the error
+    this.logError(swError);
+
+    // Track the error
+    this.trackError(swError);
+
+    return swError;
+  }
+
+  /**
+   * Creates and handles a network error
+   */
+  public handleNetworkError(
+    message: string,
+    url: string,
+    originalError?: Error,
+    context: Partial<IErrorContext> = {}
+  ): ServiceWorkerError {
+    return this.handle(
+      originalError || message,
+      ServiceWorkerErrorType.NETWORK,
+      ErrorSeverity.WARN,
+      { url, ...context }
+    );
+  }
+
+  /**
+   * Creates and handles a cache error
+   */
+  public handleCacheError(
+    message: string,
+    url?: string,
+    originalError?: Error,
+    context: Partial<IErrorContext> = {}
+  ): ServiceWorkerError {
+    return this.handle(
+      originalError || message,
+      ServiceWorkerErrorType.CACHE,
+      ErrorSeverity.ERROR,
+      { url, ...context }
+    );
+  }
+
+  /**
+   * Creates and handles an update error
+   */
+  public handleUpdateError(
+    message: string,
+    originalError?: Error,
+    context: Partial<IErrorContext> = {}
+  ): ServiceWorkerError {
+    return this.handle(
+      originalError || message,
+      ServiceWorkerErrorType.UPDATE,
+      ErrorSeverity.ERROR,
+      context
+    );
+  }
+
+  /**
+   * Creates and handles a connection error
+   */
+  public handleConnectionError(
+    message: string,
+    originalError?: Error,
+    context: Partial<IErrorContext> = {}
+  ): ServiceWorkerError {
+    return this.handle(
+      originalError || message,
+      ServiceWorkerErrorType.CONNECTION,
+      ErrorSeverity.WARN,
+      context
+    );
+  }
+
+  /**
+   * Creates and handles a timeout error
+   */
+  public handleTimeoutError(
+    message: string,
+    url?: string,
+    duration?: number,
+    context: Partial<IErrorContext> = {}
+  ): ServiceWorkerError {
+    return this.handle(
+      message,
+      ServiceWorkerErrorType.TIMEOUT,
+      ErrorSeverity.WARN,
+      { url, duration, ...context }
+    );
+  }
+
+  /**
+   * Gets the error history
+   */
+  public getErrorHistory(): ServiceWorkerError[] {
+    return [...this.errorHistory];
+  }
+
+  /**
+   * Gets errors by type
+   */
+  public getErrorsByType(type: ServiceWorkerErrorType): ServiceWorkerError[] {
+    return this.errorHistory.filter((e) => e.type === type);
+  }
+
+  /**
+   * Gets errors within a time range
+   */
+  public getRecentErrors(withinMs: number): ServiceWorkerError[] {
+    const cutoff = Date.now() - withinMs;
+    return this.errorHistory.filter((e) => e.timestamp >= cutoff);
+  }
+
+  /**
+   * Clears the error history
+   */
+  public clearHistory(): void {
+    this.errorHistory = [];
+  }
+
+  /**
+   * Gets error statistics
+   */
+  public getStats(): Record<ServiceWorkerErrorType, number> {
+    const stats: Record<ServiceWorkerErrorType, number> = {
+      [ServiceWorkerErrorType.NETWORK]: 0,
+      [ServiceWorkerErrorType.CACHE]: 0,
+      [ServiceWorkerErrorType.UPDATE]: 0,
+      [ServiceWorkerErrorType.CONNECTION]: 0,
+      [ServiceWorkerErrorType.TIMEOUT]: 0,
+      [ServiceWorkerErrorType.UNKNOWN]: 0,
+    };
+
+    for (const error of this.errorHistory) {
+      stats[error.type]++;
+    }
+
+    return stats;
+  }
+
+  /**
+   * Logs an error with the appropriate severity
+   */
+  private logError(error: ServiceWorkerError): void {
+    const logMessage = error.toLogMessage();
+
+    switch (error.severity) {
+      case ErrorSeverity.DEBUG:
+        logger.log('note', logMessage);
+        break;
+      case ErrorSeverity.INFO:
+        logger.log('info', logMessage);
+        break;
+      case ErrorSeverity.WARN:
+        logger.log('warn', logMessage);
+        break;
+      case ErrorSeverity.ERROR:
+      case ErrorSeverity.FATAL:
+        logger.log('error', logMessage);
+        break;
+    }
+  }
+
+  /**
+   * Tracks an error in the history
+   */
+  private trackError(error: ServiceWorkerError): void {
+    this.errorHistory.push(error);
+
+    // Trim history if needed
+    if (this.errorHistory.length > this.maxHistorySize) {
+      this.errorHistory = this.errorHistory.slice(-this.maxHistorySize);
+    }
+  }
+}
+
+// Export singleton getter for convenience
+export const getErrorHandler = (): ErrorHandler => ErrorHandler.getInstance();
--- a/ts_web_serviceworker/classes.eventbus.ts
+++ b/ts_web_serviceworker/classes.eventbus.ts
@@ -0,0 +1,409 @@
+import { logger } from './logging.js';
+
+/**
+ * Event types for service worker internal communication
+ */
+export enum ServiceWorkerEvent {
+  // Cache events
+  CACHE_HIT = 'cache:hit',
+  CACHE_MISS = 'cache:miss',
+  CACHE_ERROR = 'cache:error',
+  CACHE_INVALIDATE = 'cache:invalidate',
+  CACHE_INVALIDATE_ALL = 'cache:invalidate_all',
+  CACHE_REVALIDATE = 'cache:revalidate',
+
+  // Update events
+  UPDATE_CHECK_START = 'update:check_start',
+  UPDATE_CHECK_COMPLETE = 'update:check_complete',
+  UPDATE_AVAILABLE = 'update:available',
+  UPDATE_APPLIED = 'update:applied',
+  UPDATE_ERROR = 'update:error',
+
+  // Network events
+  NETWORK_REQUEST_START = 'network:request_start',
+  NETWORK_REQUEST_COMPLETE = 'network:request_complete',
+  NETWORK_REQUEST_ERROR = 'network:request_error',
+  NETWORK_ONLINE = 'network:online',
+  NETWORK_OFFLINE = 'network:offline',
+
+  // Connection events
+  CLIENT_CONNECTED = 'connection:client_connected',
+  CLIENT_DISCONNECTED = 'connection:client_disconnected',
+
+  // Lifecycle events
+  INSTALL = 'lifecycle:install',
+  ACTIVATE = 'lifecycle:activate',
+  READY = 'lifecycle:ready',
+}
+
+/**
+ * Event payload interfaces
+ */
+export interface ICacheEventPayload {
+  url: string;
+  method?: string;
+  bytes?: number;
+  error?: string;
+}
+
+export interface IUpdateEventPayload {
+  oldVersion?: string;
+  newVersion?: string;
+  oldHash?: string;
+  newHash?: string;
+  error?: string;
+}
+
+export interface INetworkEventPayload {
+  url: string;
+  method?: string;
+  status?: number;
+  duration?: number;
+  bytes?: number;
+  error?: string;
+}
+
+export interface IConnectionEventPayload {
+  clientId?: string;
+  tabId?: string;
+}
+
+export interface ILifecycleEventPayload {
+  timestamp: number;
+}
+
+/**
+ * Union type for all event payloads
+ */
+export type TEventPayload =
+  | ICacheEventPayload
+  | IUpdateEventPayload
+  | INetworkEventPayload
+  | IConnectionEventPayload
+  | ILifecycleEventPayload
+  | Record<string, unknown>;
+
+/**
+ * Event listener callback type
+ */
+export type TEventListener<T extends TEventPayload = TEventPayload> = (
+  event: ServiceWorkerEvent,
+  payload: T
+) => void | Promise<void>;
+
+/**
+ * Subscription interface
+ */
+export interface ISubscription {
+  unsubscribe: () => void;
+}
+
+/**
+ * Event bus for decoupled communication between service worker components.
+ * Implements a simple pub/sub pattern.
+ */
+export class EventBus {
+  private static instance: EventBus;
+  private listeners: Map<ServiceWorkerEvent, Set<TEventListener>>;
+  private globalListeners: Set<TEventListener>;
+  private eventHistory: Array<{ event: ServiceWorkerEvent; payload: TEventPayload; timestamp: number }>;
+  private readonly maxHistorySize = 100;
+  private debugMode = false;
+
+  private constructor() {
+    this.listeners = new Map();
+    this.globalListeners = new Set();
+    this.eventHistory = [];
+  }
+
+  /**
+   * Gets the singleton instance
+   */
+  public static getInstance(): EventBus {
+    if (!EventBus.instance) {
+      EventBus.instance = new EventBus();
+    }
+    return EventBus.instance;
+  }
+
+  /**
+   * Enables or disables debug mode (logs all events)
+   */
+  public setDebugMode(enabled: boolean): void {
+    this.debugMode = enabled;
+  }
+
+  /**
+   * Emits an event to all subscribed listeners
+   */
+  public emit<T extends TEventPayload>(event: ServiceWorkerEvent, payload: T): void {
+    if (this.debugMode) {
+      logger.log('note', `[EventBus] Emit: ${event} ${JSON.stringify(payload)}`);
+    }
+
+    // Record in history
+    this.recordEvent(event, payload);
+
+    // Notify specific listeners
+    const specificListeners = this.listeners.get(event);
+    if (specificListeners) {
+      for (const listener of specificListeners) {
+        try {
+          const result = listener(event, payload);
+          if (result instanceof Promise) {
+            result.catch((err) => {
+              logger.log('error', `[EventBus] Async listener error for ${event}: ${err}`);
+            });
+          }
+        } catch (err) {
+          logger.log('error', `[EventBus] Listener error for ${event}: ${err}`);
+        }
+      }
+    }
+
+    // Notify global listeners
+    for (const listener of this.globalListeners) {
+      try {
+        const result = listener(event, payload);
+        if (result instanceof Promise) {
+          result.catch((err) => {
+            logger.log('error', `[EventBus] Global async listener error for ${event}: ${err}`);
+          });
+        }
+      } catch (err) {
+        logger.log('error', `[EventBus] Global listener error for ${event}: ${err}`);
+      }
+    }
+  }
+
+  /**
+   * Subscribes to a specific event
+   */
+  public on<T extends TEventPayload>(
+    event: ServiceWorkerEvent,
+    listener: TEventListener<T>
+  ): ISubscription {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set());
+    }
+
+    this.listeners.get(event)!.add(listener as TEventListener);
+
+    return {
+      unsubscribe: () => {
+        this.off(event, listener as TEventListener);
+      },
+    };
+  }
+
+  /**
+   * Subscribes to multiple events at once
+   */
+  public onMany<T extends TEventPayload>(
+    events: ServiceWorkerEvent[],
+    listener: TEventListener<T>
+  ): ISubscription {
+    const subscriptions = events.map((event) =>
+      this.on(event, listener as TEventListener)
+    );
+
+    return {
+      unsubscribe: () => {
+        subscriptions.forEach((sub) => sub.unsubscribe());
+      },
+    };
+  }
+
+  /**
+   * Subscribes to all events
+   */
+  public onAll<T extends TEventPayload>(listener: TEventListener<T>): ISubscription {
+    this.globalListeners.add(listener as TEventListener);
+
+    return {
+      unsubscribe: () => {
+        this.globalListeners.delete(listener as TEventListener);
+      },
+    };
+  }
+
+  /**
+   * Subscribes to an event for only one emission
+   */
+  public once<T extends TEventPayload>(
+    event: ServiceWorkerEvent,
+    listener: TEventListener<T>
+  ): ISubscription {
+    const onceListener: TEventListener = (evt, payload) => {
+      this.off(event, onceListener);
+      return listener(evt, payload as T);
+    };
+
+    return this.on(event, onceListener);
+  }
+
+  /**
+   * Unsubscribes a listener from an event
+   */
+  public off(event: ServiceWorkerEvent, listener: TEventListener): void {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        this.listeners.delete(event);
+      }
+    }
+  }
+
+  /**
+   * Removes all listeners for an event
+   */
+  public removeAllListeners(event?: ServiceWorkerEvent): void {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+      this.globalListeners.clear();
+    }
+  }
+
+  /**
+   * Gets the count of listeners for an event
+   */
+  public listenerCount(event: ServiceWorkerEvent): number {
+    const listeners = this.listeners.get(event);
+    return (listeners?.size ?? 0) + this.globalListeners.size;
+  }
+
+  /**
+   * Gets the event history
+   */
+  public getHistory(): Array<{ event: ServiceWorkerEvent; payload: TEventPayload; timestamp: number }> {
+    return [...this.eventHistory];
+  }
+
+  /**
+   * Gets events of a specific type from history
+   */
+  public getHistoryByType(event: ServiceWorkerEvent): Array<{ payload: TEventPayload; timestamp: number }> {
+    return this.eventHistory
+      .filter((entry) => entry.event === event)
+      .map(({ payload, timestamp }) => ({ payload, timestamp }));
+  }
+
+  /**
+   * Clears the event history
+   */
+  public clearHistory(): void {
+    this.eventHistory = [];
+  }
+
+  /**
+   * Waits for an event to be emitted (returns a promise)
+   */
+  public waitFor<T extends TEventPayload>(
+    event: ServiceWorkerEvent,
+    timeout?: number
+  ): Promise<T> {
+    return new Promise((resolve, reject) => {
+      let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+      const subscription = this.once<T>(event, (_, payload) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve(payload);
+      });
+
+      if (timeout) {
+        timeoutId = setTimeout(() => {
+          subscription.unsubscribe();
+          reject(new Error(`Timeout waiting for event: ${event}`));
+        }, timeout);
+      }
+    });
+  }
+
+  /**
+   * Records an event in history
+   */
+  private recordEvent(event: ServiceWorkerEvent, payload: TEventPayload): void {
+    this.eventHistory.push({
+      event,
+      payload,
+      timestamp: Date.now(),
+    });
+
+    // Trim history if needed
+    if (this.eventHistory.length > this.maxHistorySize) {
+      this.eventHistory = this.eventHistory.slice(-this.maxHistorySize);
+    }
+  }
+
+  // ===================
+  // Convenience Methods
+  // ===================
+
+  /**
+   * Emits a cache hit event
+   */
+  public emitCacheHit(url: string, bytes?: number): void {
+    this.emit(ServiceWorkerEvent.CACHE_HIT, { url, bytes });
+  }
+
+  /**
+   * Emits a cache miss event
+   */
+  public emitCacheMiss(url: string): void {
+    this.emit(ServiceWorkerEvent.CACHE_MISS, { url });
+  }
+
+  /**
+   * Emits a cache error event
+   */
+  public emitCacheError(url: string, error?: string): void {
+    this.emit(ServiceWorkerEvent.CACHE_ERROR, { url, error });
+  }
+
+  /**
+   * Emits a cache invalidation event
+   */
+  public emitCacheInvalidate(url?: string): void {
+    if (url) {
+      this.emit(ServiceWorkerEvent.CACHE_INVALIDATE, { url });
+    } else {
+      this.emit(ServiceWorkerEvent.CACHE_INVALIDATE_ALL, {});
+    }
+  }
+
+  /**
+   * Emits an update available event
+   */
+  public emitUpdateAvailable(oldVersion: string, newVersion: string, oldHash: string, newHash: string): void {
+    this.emit(ServiceWorkerEvent.UPDATE_AVAILABLE, { oldVersion, newVersion, oldHash, newHash });
+  }
+
+  /**
+   * Emits an update applied event
+   */
+  public emitUpdateApplied(newVersion: string, newHash: string): void {
+    this.emit(ServiceWorkerEvent.UPDATE_APPLIED, { newVersion, newHash });
+  }
+
+  /**
+   * Emits a network online event
+   */
+  public emitNetworkOnline(): void {
+    this.emit(ServiceWorkerEvent.NETWORK_ONLINE, {});
+  }
+
+  /**
+   * Emits a network offline event
+   */
+  public emitNetworkOffline(): void {
+    this.emit(ServiceWorkerEvent.NETWORK_OFFLINE, {});
+  }
+}
+
+// Export singleton getter for convenience
+export const getEventBus = (): EventBus => EventBus.getInstance();
--- a/ts_web_serviceworker/classes.metrics.ts
+++ b/ts_web_serviceworker/classes.metrics.ts
@@ -0,0 +1,697 @@
+import { logger } from './logging.js';
+import { getServiceWorkerBackend } from './init.js';
+
+/**
+ * Interface for cache metrics
+ */
+export interface ICacheMetrics {
+  hits: number;
+  misses: number;
+  errors: number;
+  bytesServedFromCache: number;
+  bytesFetched: number;
+  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
+ */
+export interface INetworkMetrics {
+  totalRequests: number;
+  successfulRequests: number;
+  failedRequests: number;
+  timeouts: number;
+  averageLatency: number;
+  totalBytesTransferred: number;
+}
+
+/**
+ * Interface for update metrics
+ */
+export interface IUpdateMetrics {
+  totalChecks: number;
+  successfulChecks: number;
+  failedChecks: number;
+  updatesFound: number;
+  updatesApplied: number;
+  lastCheckTimestamp: number;
+  lastUpdateTimestamp: number;
+}
+
+/**
+ * Interface for connection metrics
+ */
+export interface IConnectionMetrics {
+  connectedClients: number;
+  totalConnectionAttempts: number;
+  successfulConnections: number;
+  failedConnections: number;
+}
+
+/**
+ * Interface for speedtest metrics
+ */
+export interface ISpeedtestMetrics {
+  lastDownloadSpeedMbps: number;
+  lastUploadSpeedMbps: number;
+  lastLatencyMs: number;
+  lastTestTimestamp: number;
+  testCount: number;
+  isOnline: boolean;
+}
+
+/**
+ * Combined metrics interface
+ */
+export interface IServiceWorkerMetrics {
+  cache: ICacheMetrics;
+  network: INetworkMetrics;
+  update: IUpdateMetrics;
+  connection: IConnectionMetrics;
+  speedtest: ISpeedtestMetrics;
+  startTime: number;
+  uptime: number;
+}
+
+/**
+ * Response time entry for calculating averages
+ */
+interface IResponseTimeEntry {
+  url: string;
+  duration: number;
+  timestamp: number;
+}
+
+/**
+ * Metrics collector for service worker observability
+ */
+export class MetricsCollector {
+  private static instance: MetricsCollector;
+
+  // Cache metrics
+  private cacheHits = 0;
+  private cacheMisses = 0;
+  private cacheErrors = 0;
+  private bytesServedFromCache = 0;
+  private bytesFetched = 0;
+
+  // Network metrics
+  private totalRequests = 0;
+  private successfulRequests = 0;
+  private failedRequests = 0;
+  private timeouts = 0;
+  private totalBytesTransferred = 0;
+
+  // Update metrics
+  private totalUpdateChecks = 0;
+  private successfulUpdateChecks = 0;
+  private failedUpdateChecks = 0;
+  private updatesFound = 0;
+  private updatesApplied = 0;
+  private lastCheckTimestamp = 0;
+  private lastUpdateTimestamp = 0;
+
+  // Connection metrics
+  private connectedClients = 0;
+  private totalConnectionAttempts = 0;
+  private successfulConnections = 0;
+  private failedConnections = 0;
+
+  // Speedtest metrics
+  private lastDownloadSpeedMbps = 0;
+  private lastUploadSpeedMbps = 0;
+  private lastLatencyMs = 0;
+  private lastSpeedtestTimestamp = 0;
+  private speedtestCount = 0;
+  private isOnline = true;
+
+  // Response time tracking
+  private responseTimes: IResponseTimeEntry[] = [];
+  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;
+
+  private constructor() {
+    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
+   */
+  public static getInstance(): MetricsCollector {
+    if (!MetricsCollector.instance) {
+      MetricsCollector.instance = new MetricsCollector();
+    }
+    return MetricsCollector.instance;
+  }
+
+  // ===================
+  // Cache Metrics
+  // ===================
+
+  public recordCacheHit(url: string, bytes: number = 0): void {
+    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 {
+    this.cacheErrors++;
+    logger.log('warn', `[Metrics] Cache error: ${url} - ${error || 'unknown'}`);
+  }
+
+  public recordBytesFetched(bytes: number): void {
+    this.bytesFetched += bytes;
+  }
+
+  // ===================
+  // Network Metrics
+  // ===================
+
+  public recordRequest(_url: string): void {
+    this.totalRequests++;
+  }
+
+  public recordRequestSuccess(url: string, duration: number, bytes: number = 0): void {
+    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 {
+    this.timeouts++;
+    logger.log('warn', `[Metrics] Request timeout: ${url} after ${duration}ms`);
+  }
+
+  // ===================
+  // Update Metrics
+  // ===================
+
+  public recordUpdateCheck(success: boolean): void {
+    this.totalUpdateChecks++;
+    this.lastCheckTimestamp = Date.now();
+    if (success) {
+      this.successfulUpdateChecks++;
+    } else {
+      this.failedUpdateChecks++;
+    }
+  }
+
+  public recordUpdateFound(): void {
+    this.updatesFound++;
+  }
+
+  public recordUpdateApplied(): void {
+    this.updatesApplied++;
+    this.lastUpdateTimestamp = Date.now();
+  }
+
+  // ===================
+  // Connection Metrics
+  // ===================
+
+  public recordConnectionAttempt(): void {
+    this.totalConnectionAttempts++;
+  }
+
+  public recordConnectionSuccess(): void {
+    this.successfulConnections++;
+    this.connectedClients++;
+  }
+
+  public recordConnectionFailure(): void {
+    this.failedConnections++;
+  }
+
+  public recordClientDisconnect(): void {
+    this.connectedClients = Math.max(0, this.connectedClients - 1);
+  }
+
+  public setConnectedClients(count: number): void {
+    this.connectedClients = count;
+  }
+
+  // ===================
+  // Speedtest Metrics
+  // ===================
+
+  public recordSpeedtest(type: 'download' | 'upload' | 'latency', value: number): void {
+    this.speedtestCount++;
+    this.lastSpeedtestTimestamp = Date.now();
+    this.isOnline = true;
+
+    switch (type) {
+      case 'download':
+        this.lastDownloadSpeedMbps = value;
+        logger.log('info', `[Metrics] Speedtest download: ${value.toFixed(2)} Mbps`);
+        break;
+      case 'upload':
+        this.lastUploadSpeedMbps = value;
+        logger.log('info', `[Metrics] Speedtest upload: ${value.toFixed(2)} Mbps`);
+        break;
+      case 'latency':
+        this.lastLatencyMs = value;
+        logger.log('info', `[Metrics] Speedtest latency: ${value.toFixed(0)} ms`);
+        break;
+    }
+  }
+
+  public setOnlineStatus(online: boolean): void {
+    this.isOnline = online;
+    logger.log('info', `[Metrics] Online status: ${online ? 'online' : 'offline'}`);
+  }
+
+  public getSpeedtestMetrics(): ISpeedtestMetrics {
+    return {
+      lastDownloadSpeedMbps: this.lastDownloadSpeedMbps,
+      lastUploadSpeedMbps: this.lastUploadSpeedMbps,
+      lastLatencyMs: this.lastLatencyMs,
+      lastTestTimestamp: this.lastSpeedtestTimestamp,
+      testCount: this.speedtestCount,
+      isOnline: this.isOnline,
+    };
+  }
+
+  // ===================
+  // Response Time Tracking
+  // ===================
+
+  private recordResponseTime(url: string, duration: number): void {
+    const entry: IResponseTimeEntry = {
+      url,
+      duration,
+      timestamp: Date.now(),
+    };
+
+    this.responseTimes.push(entry);
+
+    // Trim old entries
+    this.cleanupResponseTimes();
+  }
+
+  private cleanupResponseTimes(): void {
+    const cutoff = Date.now() - this.responseTimeWindow;
+
+    // Remove old entries
+    this.responseTimes = this.responseTimes.filter(
+      (entry) => entry.timestamp >= cutoff
+    );
+
+    // Keep within max size
+    if (this.responseTimes.length > this.maxResponseTimeEntries) {
+      this.responseTimes = this.responseTimes.slice(-this.maxResponseTimeEntries);
+    }
+  }
+
+  private calculateAverageResponseTime(): number {
+    if (this.responseTimes.length === 0) {
+      return 0;
+    }
+
+    const sum = this.responseTimes.reduce((acc, entry) => acc + entry.duration, 0);
+    return Math.round(sum / this.responseTimes.length);
+  }
+
+  private calculateAverageLatency(): number {
+    // Same as response time for now
+    return this.calculateAverageResponseTime();
+  }
+
+  // ===================
+  // Metrics Retrieval
+  // ===================
+
+  /**
+   * Gets all metrics
+   */
+  public getMetrics(): IServiceWorkerMetrics {
+    const now = Date.now();
+    this.cleanupResponseTimes();
+
+    return {
+      cache: {
+        hits: this.cacheHits,
+        misses: this.cacheMisses,
+        errors: this.cacheErrors,
+        bytesServedFromCache: this.bytesServedFromCache,
+        bytesFetched: this.bytesFetched,
+        averageResponseTime: this.calculateAverageResponseTime(),
+      },
+      network: {
+        totalRequests: this.totalRequests,
+        successfulRequests: this.successfulRequests,
+        failedRequests: this.failedRequests,
+        timeouts: this.timeouts,
+        averageLatency: this.calculateAverageLatency(),
+        totalBytesTransferred: this.totalBytesTransferred,
+      },
+      update: {
+        totalChecks: this.totalUpdateChecks,
+        successfulChecks: this.successfulUpdateChecks,
+        failedChecks: this.failedUpdateChecks,
+        updatesFound: this.updatesFound,
+        updatesApplied: this.updatesApplied,
+        lastCheckTimestamp: this.lastCheckTimestamp,
+        lastUpdateTimestamp: this.lastUpdateTimestamp,
+      },
+      connection: {
+        connectedClients: this.connectedClients,
+        totalConnectionAttempts: this.totalConnectionAttempts,
+        successfulConnections: this.successfulConnections,
+        failedConnections: this.failedConnections,
+      },
+      speedtest: {
+        lastDownloadSpeedMbps: this.lastDownloadSpeedMbps,
+        lastUploadSpeedMbps: this.lastUploadSpeedMbps,
+        lastLatencyMs: this.lastLatencyMs,
+        lastTestTimestamp: this.lastSpeedtestTimestamp,
+        testCount: this.speedtestCount,
+        isOnline: this.isOnline,
+      },
+      startTime: this.startTime,
+      uptime: now - this.startTime,
+    };
+  }
+
+  /**
+   * Gets cache hit rate as a percentage
+   */
+  public getCacheHitRate(): number {
+    const total = this.cacheHits + this.cacheMisses;
+    if (total === 0) {
+      return 0;
+    }
+    return Math.round((this.cacheHits / total) * 100);
+  }
+
+  /**
+   * Gets network success rate as a percentage
+   */
+  public getNetworkSuccessRate(): number {
+    if (this.totalRequests === 0) {
+      return 100;
+    }
+    return Math.round((this.successfulRequests / this.totalRequests) * 100);
+  }
+
+  /**
+   * Resets all metrics
+   */
+  public reset(): void {
+    this.cacheHits = 0;
+    this.cacheMisses = 0;
+    this.cacheErrors = 0;
+    this.bytesServedFromCache = 0;
+    this.bytesFetched = 0;
+
+    this.totalRequests = 0;
+    this.successfulRequests = 0;
+    this.failedRequests = 0;
+    this.timeouts = 0;
+    this.totalBytesTransferred = 0;
+
+    this.totalUpdateChecks = 0;
+    this.successfulUpdateChecks = 0;
+    this.failedUpdateChecks = 0;
+    this.updatesFound = 0;
+    this.updatesApplied = 0;
+    this.lastCheckTimestamp = 0;
+    this.lastUpdateTimestamp = 0;
+
+    this.totalConnectionAttempts = 0;
+    this.successfulConnections = 0;
+    this.failedConnections = 0;
+
+    this.lastDownloadSpeedMbps = 0;
+    this.lastUploadSpeedMbps = 0;
+    this.lastLatencyMs = 0;
+    this.lastSpeedtestTimestamp = 0;
+    this.speedtestCount = 0;
+    // Note: isOnline is not reset as it reflects current state
+
+    this.responseTimes = [];
+    this.resourceStats.clear();
+
+    logger.log('info', '[Metrics] All metrics reset');
+  }
+
+  /**
+   * Gets a summary string for logging
+   */
+  public getSummary(): string {
+    const metrics = this.getMetrics();
+    return [
+      `Cache: ${this.getCacheHitRate()}% hit rate (${metrics.cache.hits}/${metrics.cache.hits + metrics.cache.misses})`,
+      `Network: ${this.getNetworkSuccessRate()}% success (${metrics.network.successfulRequests}/${metrics.network.totalRequests})`,
+      `Updates: ${metrics.update.updatesFound} found, ${metrics.update.updatesApplied} applied`,
+      `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
+export const getMetricsCollector = (): MetricsCollector => MetricsCollector.getInstance();
--- a/ts_web_serviceworker/classes.networkmanager.ts
+++ b/ts_web_serviceworker/classes.networkmanager.ts
@@ -4,7 +4,7 @@ import { logger } from './logging.js';

 export class NetworkManager {
  public serviceWorkerRef: ServiceWorker;
-  public webRequest: plugins.webrequest.WebRequest;
+  public webRequest: plugins.webrequest.WebrequestClient;
  private isOffline: boolean = false;
  private lastOnlineCheck: number = 0;
  private readonly ONLINE_CHECK_INTERVAL = 30000; // 30 seconds
@@ -13,7 +13,7 @@ export class NetworkManager {

  constructor(serviceWorkerRefArg: ServiceWorker) {
    this.serviceWorkerRef = serviceWorkerRefArg;
-    this.webRequest = new plugins.webrequest.WebRequest();
+    this.webRequest = new plugins.webrequest.WebrequestClient();
    
    // Listen for connection changes
    this.getConnection()?.addEventListener('change', () => {
@@ -64,7 +64,7 @@ export class NetworkManager {
    }

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

+  // TypedSocket connection for server communication
+  public typedsocket: plugins.typedsocket.TypedSocket;
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+  private handlersInitialized = false;
+
  constructor(selfArg: interfaces.ServiceWindow) {
    logger.log('info', `Service worker instantiating at ${Date.now()}`);
    this.serviceWindowRef = selfArg;
@@ -59,6 +65,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();
@@ -76,16 +90,88 @@ export class ServiceWorker {
      try {
        await selfArg.clients.claim();
        logger.log('ok', 'Clients claimed successfully');
-        
+
        await this.cacheManager.cleanCaches('new service worker loaded! :)');
        logger.log('ok', 'Caches cleaned successfully');
-        
+
+        // 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()}`);
+
+        // Connect to TypedServer for cache invalidation after activation
+        this.connectToServer();
      } catch (error) {
        logger.log('error', `Service worker activation error: ${error}`);
        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();
+    }
+  }
+
+  /**
+   * Initialize typed handlers (idempotent - safe to call multiple times)
+   */
+  private initHandlers(): void {
+    if (this.handlersInitialized) return;
+    this.handlersInitialized = true;
+
+    // Register handler for cache invalidation from server
+    this.typedrouter.addTypedHandler<interfaces.serviceworker.IRequest_Serviceworker_CacheInvalidate>(
+      new plugins.typedrequest.TypedHandler('serviceworker_cacheInvalidate', async (reqArg) => {
+        logger.log('info', `Cache invalidation requested from server: ${reqArg.reason}`);
+
+        // 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();
+        return { success: true };
+      })
+    );
+  }
+
+  /**
+   * Connect to TypedServer via TypedSocket for cache invalidation
+   */
+  private async connectToServer(): Promise<void> {
+    try {
+      this.initHandlers();
+
+      // Connect to server via TypedSocket
+      this.typedsocket = await plugins.typedsocket.TypedSocket.createClient(
+        this.typedrouter,
+        this.serviceWindowRef.location.origin
+      );
+
+      // Tag this connection as a service worker for server-side filtering
+      await this.typedsocket.setTag('serviceworker', {});
+
+      logger.log('ok', 'Service worker connected to TypedServer via TypedSocket');
+    } catch (error: any) {
+      logger.log('warn', `Service worker TypedSocket connection failed: ${error?.message || error}`);
+      // Retry connection after a delay
+      setTimeout(() => this.connectToServer(), 10000);
+    }
  }
 }
--- a/ts_web_serviceworker/classes.updatemanager.ts
+++ b/ts_web_serviceworker/classes.updatemanager.ts
@@ -3,6 +3,9 @@ import * as interfaces from '../dist_ts_interfaces/index.js';
 import { ServiceWorker } from './classes.serviceworker.js';
 import { logger } from './logging.js';
 import { CacheManager } from './classes.cachemanager.js';
+import { getMetricsCollector } from './classes.metrics.js';
+import { getEventBus, ServiceWorkerEvent } from './classes.eventbus.js';
+import { getErrorHandler, ServiceWorkerErrorType } from './classes.errorhandler.js';

 export class UpdateManager {
  public lastUpdateCheck: number = 0;
@@ -10,6 +13,10 @@ export class UpdateManager {

  public serviceworkerRef: ServiceWorker;

+  // Rate limiting for update checks
+  private isCheckInProgress = false;
+  private pendingCheckPromise: Promise<boolean> | null = null;
+
  constructor(serviceWorkerRefArg: ServiceWorker) {
    this.serviceworkerRef = serviceWorkerRefArg;
  }
@@ -22,75 +29,144 @@ export class UpdateManager {
  private readonly OFFLINE_GRACE_PERIOD = 7 * 24 * 60 * 60 * 1000; // 7 days grace period when offline
  private lastCacheTimestamp: number = 0;

-  public async checkUpdate(cacheManager: CacheManager): Promise<boolean> {
-    const lswVersionInfoKey = 'versionInfo';
-    const cacheTimestampKey = 'cacheTimestamp';
-
-    // Initialize or load version info
-    if (!this.lastVersionInfo && !(await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
-      this.lastVersionInfo = {
-        appHash: '',
-        appSemVer: 'v0.0.0',
-      };
-    } else if (!this.lastVersionInfo && (await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
-      this.lastVersionInfo = await this.serviceworkerRef.store.get(lswVersionInfoKey);
-    }
-
-    // Load or initialize cache timestamp
-    if (await this.serviceworkerRef.store.check(cacheTimestampKey)) {
-      this.lastCacheTimestamp = await this.serviceworkerRef.store.get(cacheTimestampKey);
-    }
-
+  /**
+   * Public method to trigger an update check (rate-limited)
+   */
+  public async checkUpdate(_cacheManager: CacheManager): Promise<boolean> {
    const now = Date.now();
    const millisSinceLastCheck = now - this.lastUpdateCheck;
-    const cacheAge = now - this.lastCacheTimestamp;

-    // Check if we need to handle stale cache
-    if (cacheAge > this.MAX_CACHE_AGE) {
-      const isOnline = await this.serviceworkerRef.networkManager.checkOnlineStatus();
-      
-      if (isOnline) {
-        logger.log('info', `Cache is older than ${this.MAX_CACHE_AGE}ms, forcing update...`);
-        await this.forceUpdate(cacheManager);
-        return true;
-      } else if (cacheAge > this.OFFLINE_GRACE_PERIOD) {
-        // If we're offline and beyond grace period, warn but continue serving cached content
-        logger.log('warn', `Cache is stale and device is offline. Cache age: ${cacheAge}ms. Using cached content with warning.`);
-        // We could potentially show a warning to the user here
-        return false;
-      } else {
-        logger.log('info', `Cache is stale but device is offline. Within grace period. Using cached content.`);
-        return false;
-      }
-    }
-
-    // Regular update check interval
-    if (millisSinceLastCheck < this.MIN_CHECK_INTERVAL && cacheAge < this.MAX_CACHE_AGE) {
+    // Rate limit: skip if we checked recently
+    if (millisSinceLastCheck < this.MIN_CHECK_INTERVAL) {
      return false;
    }
-    logger.log('info', 'checking for update of the app by comparing app hashes...');
-    this.lastUpdateCheck = now;
-    const currentVersionInfo = await this.getVersionInfoFromServer();
-    logger.log('info', `old versionInfo: ${JSON.stringify(this.lastVersionInfo)}`);
-    logger.log('info', `current versionInfo: ${JSON.stringify(currentVersionInfo)}`);
-    const needsUpdate = this.lastVersionInfo.appHash !== currentVersionInfo.appHash ? true : false;
-    if (needsUpdate) {
-      logger.log('info', 'Caches need to be updated');
-      logger.log('info', 'starting a debounced update task');
-      this.performAsyncUpdateDebouncedTask.trigger();
-      this.lastVersionInfo = currentVersionInfo;
-      await this.serviceworkerRef.store.set(lswVersionInfoKey, this.lastVersionInfo);
-      
-      // Update cache timestamp
-      this.lastCacheTimestamp = now;
-      await this.serviceworkerRef.store.set('cacheTimestamp', now);
-    } else {
-      logger.log('ok', 'caches are still valid, performing revalidation in a bit...');
-      this.performAsyncCacheRevalidationDebouncedTask.trigger();
-      
-      // Update cache timestamp after successful revalidation
-      this.lastCacheTimestamp = now;
-      await this.serviceworkerRef.store.set('cacheTimestamp', now);
+
+    // If a check is in progress, return the existing promise
+    if (this.pendingCheckPromise) {
+      return this.pendingCheckPromise;
+    }
+
+    // Perform the check
+    this.pendingCheckPromise = this.performUpdateCheck().finally(() => {
+      this.pendingCheckPromise = null;
+    });
+
+    return this.pendingCheckPromise;
+  }
+
+  /**
+   * Internal method that performs the actual update check
+   */
+  private async performUpdateCheck(): Promise<boolean> {
+    // Prevent concurrent checks
+    if (this.isCheckInProgress) {
+      logger.log('note', 'Update check already in progress, skipping...');
+      return false;
+    }
+
+    this.isCheckInProgress = true;
+    const metrics = getMetricsCollector();
+    const eventBus = getEventBus();
+    const errorHandler = getErrorHandler();
+
+    try {
+      eventBus.emit(ServiceWorkerEvent.UPDATE_CHECK_START, { timestamp: Date.now() });
+
+      const lswVersionInfoKey = 'versionInfo';
+      const cacheTimestampKey = 'cacheTimestamp';
+
+      // Initialize or load version info
+      if (!this.lastVersionInfo && !(await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
+        this.lastVersionInfo = {
+          appHash: '',
+          appSemVer: 'v0.0.0',
+        };
+      } else if (!this.lastVersionInfo && (await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
+        this.lastVersionInfo = await this.serviceworkerRef.store.get(lswVersionInfoKey);
+      }
+
+      // Load or initialize cache timestamp
+      if (await this.serviceworkerRef.store.check(cacheTimestampKey)) {
+        this.lastCacheTimestamp = await this.serviceworkerRef.store.get(cacheTimestampKey);
+      }
+
+      const now = Date.now();
+      const cacheAge = now - this.lastCacheTimestamp;
+
+      // Check if we need to handle stale cache
+      if (cacheAge > this.MAX_CACHE_AGE) {
+        const isOnline = await this.serviceworkerRef.networkManager.checkOnlineStatus();
+
+        if (isOnline) {
+          logger.log('info', `Cache is older than ${this.MAX_CACHE_AGE}ms, forcing update...`);
+          await this.forceUpdate(this.serviceworkerRef.cacheManager);
+          metrics.recordUpdateCheck(true);
+          return true;
+        } else if (cacheAge > this.OFFLINE_GRACE_PERIOD) {
+          logger.log('warn', `Cache is stale and device is offline. Cache age: ${cacheAge}ms. Using cached content with warning.`);
+          metrics.recordUpdateCheck(false);
+          return false;
+        } else {
+          logger.log('info', `Cache is stale but device is offline. Within grace period. Using cached content.`);
+          metrics.recordUpdateCheck(false);
+          return false;
+        }
+      }
+
+      logger.log('info', 'checking for update of the app by comparing app hashes...');
+      this.lastUpdateCheck = Date.now();
+
+      const currentVersionInfo = await this.getVersionInfoFromServer();
+      logger.log('info', `old versionInfo: ${JSON.stringify(this.lastVersionInfo)}`);
+      logger.log('info', `current versionInfo: ${JSON.stringify(currentVersionInfo)}`);
+
+      const needsUpdate = this.lastVersionInfo.appHash !== currentVersionInfo.appHash;
+
+      if (needsUpdate) {
+        logger.log('info', 'Caches need to be updated');
+        logger.log('info', 'starting a debounced update task');
+
+        metrics.recordUpdateFound();
+        eventBus.emitUpdateAvailable(
+          this.lastVersionInfo.appSemVer,
+          currentVersionInfo.appSemVer,
+          this.lastVersionInfo.appHash,
+          currentVersionInfo.appHash
+        );
+
+        this.performAsyncUpdateDebouncedTask.trigger();
+        this.lastVersionInfo = currentVersionInfo;
+        await this.serviceworkerRef.store.set(lswVersionInfoKey, this.lastVersionInfo);
+
+        // Update cache timestamp
+        this.lastCacheTimestamp = now;
+        await this.serviceworkerRef.store.set('cacheTimestamp', now);
+      } else {
+        logger.log('ok', 'caches are still valid, performing revalidation in a bit...');
+        this.performAsyncCacheRevalidationDebouncedTask.trigger();
+
+        // Update cache timestamp after successful revalidation
+        this.lastCacheTimestamp = now;
+        await this.serviceworkerRef.store.set('cacheTimestamp', now);
+      }
+
+      metrics.recordUpdateCheck(true);
+      eventBus.emit(ServiceWorkerEvent.UPDATE_CHECK_COMPLETE, {
+        needsUpdate,
+        timestamp: Date.now()
+      });
+
+      return needsUpdate;
+    } catch (error) {
+      const err = errorHandler.handleUpdateError(
+        `Update check failed: ${error?.message || error}`,
+        error instanceof Error ? error : undefined
+      );
+      metrics.recordUpdateCheck(false);
+      eventBus.emit(ServiceWorkerEvent.UPDATE_ERROR, { error: err.message });
+      return false;
+    } finally {
+      this.isCheckInProgress = false;
    }
  }

@@ -101,7 +177,7 @@ export class UpdateManager {
    try {
      const getAppHashRequest = new plugins.typedrequest.TypedRequest<
        interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo
-      >('/sw-typedrequest', 'serviceworker_versionInfo');
+      >('/typedrequest', 'serviceworker_versionInfo');
      
      // Use networkManager for the request with retries and timeout
      const response = await getAppHashRequest.fire({});
@@ -140,9 +216,18 @@ export class UpdateManager {
    name: 'performAsyncUpdate',
    taskFunction: async () => {
      logger.log('info', 'trying to update PWA with serviceworker');
+      const metrics = getMetricsCollector();
+      const eventBus = getEventBus();
+
      await this.serviceworkerRef.cacheManager.cleanCaches('a new app version has been communicated by the server.');
      // lets notify all current clients about the update
      await this.serviceworkerRef.leleServiceWorkerBackend.triggerReloadAll();
+
+      metrics.recordUpdateApplied();
+      eventBus.emitUpdateApplied(
+        this.lastVersionInfo?.appSemVer || 'unknown',
+        this.lastVersionInfo?.appHash || 'unknown'
+      );
    },
    debounceTimeInMillis: 2000,
  });
--- a/ts_web_serviceworker/env.ts
+++ b/ts_web_serviceworker/env.ts
@@ -16,5 +16,6 @@ export interface ServiceWindow extends Window {
  location: any;
  skipWaiting: any;
  clients: any;
+  registration?: ServiceWorkerRegistration;
 }
 declare var self: Window;
--- a/ts_web_serviceworker/index.ts
+++ b/ts_web_serviceworker/index.ts
@@ -1,7 +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);
+// 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';
--- a/ts_web_serviceworker/init.ts
+++ b/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;
--- a/ts_web_serviceworker/plugins.ts
+++ b/ts_web_serviceworker/plugins.ts
@@ -5,8 +5,9 @@ export { interfaces };

 // @apiglobal scope
 import * as typedrequest from '@api.global/typedrequest';
+import * as typedsocket from '@api.global/typedsocket';

-export { typedrequest };
+export { typedrequest, typedsocket };

 // @pushrocks scope
 import * as smartdelay from '@push.rocks/smartdelay';
--- a/ts_web_serviceworker_client/classes.actionmanager.ts
+++ b/ts_web_serviceworker_client/classes.actionmanager.ts
@@ -2,13 +2,38 @@ import * as plugins from './plugins.js';
 import * as interfaces from '../dist_ts_interfaces/index.js';
 import { logger } from './logging.js';

+/**
+ * Connection options for service worker connection attempts
+ */
+export interface IConnectionOptions {
+  timeoutMs: number;      // Total timeout for all attempts (default: 30000)
+  maxRetries: number;     // Maximum number of retry attempts (default: 10)
+  initialDelayMs: number; // Initial delay between retries (default: 500)
+  maxDelayMs: number;     // Maximum delay between retries (default: 5000)
+  backoffMultiplier: number; // Multiplier for exponential backoff (default: 1.5)
+}
+
+const DEFAULT_CONNECTION_OPTIONS: IConnectionOptions = {
+  timeoutMs: 30000,
+  maxRetries: 10,
+  initialDelayMs: 500,
+  maxDelayMs: 5000,
+  backoffMultiplier: 1.5,
+};
+
 /**
 * MessageManager implements two ways of serviceworker communication
 * * 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
@@ -18,30 +43,141 @@ 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 {};
+    });
  }

-  public async waitForServiceWorkerConnection () {
-    console.log('waiting for service worker connection...')
-    const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Client_Serviceworker_ConnectionPolling>('broadcastConnectionPolling');
-    let connected = false;
-    while (!connected) {
-      tr.fire({
-        tabId: '123'
-      }).then(response => {
-        if (response.serviceworkerId) {
-          console.log('connected to serviceworker!');
-          connected = true;
-        }
-      }).catch();
-      await plugins.smartdelay.delayFor(777);
-      if (!connected) {
-        // lets wake it up.
-        navigator.serviceWorker.controller.postMessage({
-          type: 'wakeUpCall',
-        });
-      }
+  /**
+   * 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;
+    }
+  }
+
+  /**
+   * Waits for service worker connection with timeout and retry logic.
+   * Returns a result object instead of blocking forever.
+   */
+  public async waitForServiceWorkerConnection(
+    options: Partial<IConnectionOptions> = {}
+  ): Promise<interfaces.serviceworker.IConnectionResult> {
+    const opts = { ...DEFAULT_CONNECTION_OPTIONS, ...options };
+    const startTime = Date.now();
+    let attempt = 0;
+    let currentDelay = opts.initialDelayMs;
+
+    logger.log('info', 'Waiting for service worker connection...');
+
+    const tr = this.deesComms.createTypedRequest<interfaces.serviceworker.IRequest_Client_Serviceworker_ConnectionPolling>('broadcastConnectionPolling');
+
+    while (attempt < opts.maxRetries) {
+      // Check total timeout
+      const elapsed = Date.now() - startTime;
+      if (elapsed >= opts.timeoutMs) {
+        logger.log('warn', `Service worker connection timeout after ${elapsed}ms (${attempt} attempts)`);
+        return {
+          connected: false,
+          error: 'timeout',
+          attempts: attempt,
+          duration: elapsed,
+        };
+      }
+
+      attempt++;
+
+      try {
+        // Create a per-request timeout
+        const requestTimeout = Math.min(currentDelay * 2, opts.maxDelayMs);
+        const response = await Promise.race([
+          tr.fire({ tabId: crypto.randomUUID?.() || String(Date.now()) }),
+          new Promise<null>((_, reject) =>
+            setTimeout(() => reject(new Error('Request timeout')), requestTimeout)
+          ),
+        ]);
+
+        if (response && response.serviceworkerId) {
+          const duration = Date.now() - startTime;
+          logger.log('ok', `Connected to service worker after ${attempt} attempt(s) (${duration}ms)`);
+          return {
+            connected: true,
+            attempts: attempt,
+            duration,
+          };
+        }
+      } catch (error) {
+        // Request failed or timed out, continue with retry
+        logger.log('note', `Connection attempt ${attempt} failed: ${error?.message || 'unknown error'}`);
+      }
+
+      // Try to wake up the service worker
+      if (navigator.serviceWorker.controller) {
+        try {
+          navigator.serviceWorker.controller.postMessage({
+            type: 'wakeUpCall',
+          });
+        } catch {
+          // Ignore errors when posting message
+        }
+      }
+
+      // Wait before next attempt with exponential backoff
+      await plugins.smartdelay.delayFor(currentDelay);
+      currentDelay = Math.min(currentDelay * opts.backoffMultiplier, opts.maxDelayMs);
+    }
+
+    const duration = Date.now() - startTime;
+    logger.log('warn', `Service worker connection failed after ${opts.maxRetries} attempts (${duration}ms)`);
+    return {
+      connected: false,
+      error: 'max_retries_exceeded',
+      attempts: attempt,
+      duration,
+    };
+  }
+
+  /**
+   * Legacy method for backward compatibility - blocks until connected or gives up
+   * @deprecated Use waitForServiceWorkerConnection() instead which returns a result
+   */
+  public async waitForServiceWorkerConnectionBlocking(): Promise<void> {
+    const result = await this.waitForServiceWorkerConnection();
+    if (!result.connected) {
+      logger.log('warn', `Failed to connect to service worker: ${result.error}`);
    }
-    console.log('ok, got serviceworker connection.')
  }

  public async purgeServiceWorkerCache () {
@@ -55,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)');
+    };
+  }
 }
--- a/ts_web_serviceworker_client/classes.globalsw.ts
+++ b/ts_web_serviceworker_client/classes.globalsw.ts
@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 import { ServiceworkerClient } from './classes.serviceworkerclient.js';
+import { ActionManager } from './classes.actionmanager.js';

 export class GlobalSW {
  losslessSw: ServiceworkerClient;
@@ -8,6 +9,13 @@ export class GlobalSW {
    globalThis.globalSw = this;
  };

+  /**
+   * Exposes the action manager for traffic logging and SW communication
+   */
+  public get actionManager(): ActionManager {
+    return this.losslessSw.actionManager;
+  }
+
  /**
   * purges the cache of the app's serviceworker
   * @returns
--- a/ts_web_serviceworker_client/classes.serviceworkerclient.ts
+++ b/ts_web_serviceworker_client/classes.serviceworkerclient.ts
@@ -5,28 +5,54 @@ import { NotificationManager } from './classes.notificationmanager.js';
 import { ActionManager } from './classes.actionmanager.js';
 import { GlobalSW } from './classes.globalsw.js'

+/**
+ * Polling options for service worker update checks
+ */
+export interface IPollingOptions {
+  intervalMs: number;         // Interval between update checks (default: 60000 - 1 minute)
+  pauseWhenHidden: boolean;   // Pause polling when page is hidden (default: true)
+  initialDelayMs: number;     // Initial delay before first poll (default: 2000)
+}
+
+const DEFAULT_POLLING_OPTIONS: IPollingOptions = {
+  intervalMs: 60000,        // 1 minute
+  pauseWhenHidden: true,
+  initialDelayMs: 2000,
+};
+
 export class ServiceworkerClient {
  // STATIC
-  public static async createServiceWorker(): Promise<ServiceworkerClient> {
+  private static pollingController: AbortController | null = null;
+  private static swRegistration: ServiceWorkerRegistration | null = null;
+  private static isPollingActive = false;
+
+  public static async createServiceWorker(
+    pollingOptions: Partial<IPollingOptions> = {}
+  ): Promise<ServiceworkerClient> {
    if ('serviceWorker' in navigator) {
      try {
        logger.log('info', 'trying to register serviceworker');
        // this is some magic for Parcel to not pick up the serviceworker
        const serviceworkerInNavigator: ServiceWorkerContainer = navigator.serviceWorker;
-        const swRegistration: ServiceWorkerRegistration = await serviceworkerInNavigator.register('/serviceworker.bundle.js', {
+        this.swRegistration = await serviceworkerInNavigator.register('/serviceworker.bundle.js', {
          scope: '/',
          updateViaCache: 'none'
        });
-        plugins.smartdelay.delayFor(2000).then(async () => {
-          swRegistration.onupdatefound = () => {
-            logger.log('info', 'update found for service worker!');
-            logger.log('warn', 'trying to find convenient time to update');
-          };
-          while(true) {
-            await plugins.smartdelay.delayFor(60000);
-            swRegistration.update();
-          }
-        });
+
+        this.swRegistration.onupdatefound = () => {
+          logger.log('info', 'update found for service worker!');
+          logger.log('warn', 'trying to find convenient time to update');
+        };
+
+        // Start polling with controllable abort mechanism
+        const opts = { ...DEFAULT_POLLING_OPTIONS, ...pollingOptions };
+        this.startPolling(opts);
+
+        // Set up visibility change handler to pause/resume polling
+        if (opts.pauseWhenHidden) {
+          this.setupVisibilityHandler(opts);
+        }
+
        logger.log('ok', 'serviceworker registered');
        await navigator.serviceWorker.ready;
        logger.log('ok', 'serviceworker is ready!');
@@ -41,6 +67,120 @@ export class ServiceworkerClient {
    }
  }

+  /**
+   * Starts the update polling loop with an AbortController
+   */
+  private static startPolling(opts: IPollingOptions): void {
+    // Cancel any existing polling
+    this.stopPolling();
+
+    this.pollingController = new AbortController();
+    this.isPollingActive = true;
+    const signal = this.pollingController.signal;
+
+    const poll = async () => {
+      // Initial delay
+      await plugins.smartdelay.delayFor(opts.initialDelayMs);
+
+      while (!signal.aborted && this.swRegistration) {
+        try {
+          // Check for updates
+          await this.swRegistration.update();
+          logger.log('note', 'Service worker update check completed');
+        } catch (err) {
+          if (!signal.aborted) {
+            logger.log('warn', `Service worker update check failed: ${err?.message || err}`);
+          }
+        }
+
+        // Wait for next interval, but check abort signal
+        if (!signal.aborted) {
+          await this.delayWithAbort(opts.intervalMs, signal);
+        }
+      }
+
+      this.isPollingActive = false;
+      logger.log('info', 'Service worker polling stopped');
+    };
+
+    // Start polling (fire and forget)
+    poll().catch((err) => {
+      if (!signal.aborted) {
+        logger.log('error', `Service worker polling error: ${err?.message || err}`);
+      }
+    });
+  }
+
+  /**
+   * Stops the polling loop
+   */
+  public static stopPolling(): void {
+    if (this.pollingController) {
+      this.pollingController.abort();
+      this.pollingController = null;
+    }
+    this.isPollingActive = false;
+  }
+
+  /**
+   * Sets up visibility change handler to pause/resume polling
+   */
+  private static setupVisibilityHandler(opts: IPollingOptions): void {
+    document.addEventListener('visibilitychange', () => {
+      if (document.visibilityState === 'hidden') {
+        // Page is hidden, stop polling to save resources
+        logger.log('note', 'Page hidden, pausing service worker polling');
+        this.stopPolling();
+      } else if (document.visibilityState === 'visible') {
+        // Page is visible again, resume polling
+        if (!this.isPollingActive && this.swRegistration) {
+          logger.log('note', 'Page visible, resuming service worker polling');
+          this.startPolling(opts);
+        }
+      }
+    });
+  }
+
+  /**
+   * Delay that can be aborted
+   */
+  private static delayWithAbort(ms: number, signal: AbortSignal): Promise<void> {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        resolve();
+      }, ms);
+
+      signal.addEventListener('abort', () => {
+        clearTimeout(timeout);
+        resolve();
+      }, { once: true });
+    });
+  }
+
+  /**
+   * Manually triggers an update check
+   */
+  public static async triggerUpdateCheck(): Promise<void> {
+    if (this.swRegistration) {
+      try {
+        await this.swRegistration.update();
+        logger.log('ok', 'Manual service worker update check completed');
+      } catch (err) {
+        logger.log('error', `Manual update check failed: ${err?.message || err}`);
+        throw err;
+      }
+    } else {
+      logger.log('warn', 'Cannot trigger update check: no service worker registration');
+    }
+  }
+
+  /**
+   * Gets whether polling is currently active
+   */
+  public static get isPolling(): boolean {
+    return this.isPollingActive;
+  }
+
  private static async waitForController() {
    const done = new plugins.smartpromise.Deferred();
    const checkReady = () => {
@@ -66,4 +206,11 @@ export class ServiceworkerClient {
    this.actionManager = new ActionManager();
    this.globalSw = new GlobalSW(this);
  }
+
+  /**
+   * Cleanup method to stop polling when the client is no longer needed
+   */
+  public destroy(): void {
+    ServiceworkerClient.stopPolling();
+  }
 }
--- a/ts_web_serviceworker_client/index.ts
+++ b/ts_web_serviceworker_client/index.ts
@@ -11,14 +11,17 @@ export type {
 import { logger } from './logging.js';
 logger.log('note', 'mainthread console initialized!');

-import { ServiceworkerClient } from './classes.serviceworkerclient.js';
+import { ServiceworkerClient, type IPollingOptions } from './classes.serviceworkerclient.js';
+import { type IConnectionOptions } from './classes.actionmanager.js';

 export type {
-  ServiceworkerClient
+  ServiceworkerClient,
+  IPollingOptions,
+  IConnectionOptions,
 }

-export const getServiceworkerClient = async () => {
-  const swClient = await ServiceworkerClient.createServiceWorker(); // lets setup the service worker
+export const getServiceworkerClient = async (pollingOptions?: Partial<IPollingOptions>) => {
+  const swClient = await ServiceworkerClient.createServiceWorker(pollingOptions); // lets setup the service worker
  logger.log('ok', 'service worker ready!'); // and wait for it to be ready
  return swClient;
 };
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,7 +1,5 @@
 {
  "compilerOptions": {
-    "experimentalDecorators": true,
-    "useDefineForClassFields": false,
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",