@angular-helpers/browser-web-apis 21.4.0 → 21.6.0

package/fesm2022/angular-helpers-browser-web-apis.mjs

@@ -1,33 +1,22 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, DestroyRef, PLATFORM_ID, signal, computed, isSignal, effect, ElementRef, makeEnvironmentProviders } from '@angular/core';
+import { InjectionToken, inject, DestroyRef, PLATFORM_ID, Injectable, signal, computed, isSignal, effect, ElementRef, makeEnvironmentProviders } from '@angular/core';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
 import { Observable, fromEvent, Subject, of, map as map$1 } from 'rxjs';
 import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
 import { filter, distinctUntilChanged, map } from 'rxjs/operators';
 import { Router } from '@angular/router';
 
-class PermissionsService {
-    async query(descriptor) {
-        if (!this.isSupported()) {
-            throw new Error('Permissions API not supported');
-        }
-        try {
-            return await navigator.permissions.query(descriptor);
-        }
-        catch (error) {
-            console.error('Error querying permission:', error);
-            throw error;
-        }
-    }
-    isSupported() {
-        return typeof navigator !== 'undefined' && 'permissions' in navigator;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService, decorators: [{
-            type: Injectable
-        }] });
+const BROWSER_API_LOGGER = new InjectionToken('BROWSER_API_LOGGER', {
+    providedIn: 'root',
+    factory: () => ({
+        // oxlint-disable-next-line no-console
+        info: (message) => console.info(message),
+        // oxlint-disable-next-line no-console
+        warn: (message) => console.warn(message),
+        // oxlint-disable-next-line no-console
+        error: (message, error) => console.error(message, error),
+    }),
+});
 
 /**
  * Base class for all Browser Web API services.
@@ -35,7 +24,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
  * - Platform detection (browser vs server)
  * - Support assertion via Template Method
  * - Error creation with cause chaining
- * - Structured logging
+ * - Structured logging via injectable BROWSER_API_LOGGER token
  * - Lifecycle management with destroyRef
  *
  * Services that also need permission querying should extend
@@ -44,6 +33,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
 class BrowserApiBaseService {
     destroyRef = inject(DestroyRef);
     platformId = inject(PLATFORM_ID);
+    logger = inject(BROWSER_API_LOGGER);
     /**
      * Check if running in browser environment using Angular's platform detection.
      */
@@ -57,8 +47,8 @@ class BrowserApiBaseService {
         return isPlatformServer(this.platformId);
     }
     /**
-     * Template Method: throws a standard error when the API is not available.
-     * Uses getApiName() to produce consistent error messages.
+     * Template Method: asserts the service can run in the current environment.
+     * Subclasses must call super.ensureSupported() and then add their own API check.
      */
     ensureSupported() {
         if (!this.isBrowserEnvironment()) {
@@ -76,16 +66,22 @@ class BrowserApiBaseService {
         return error;
     }
     /**
-     * Log an error with the service name as prefix.
+     * Log an error through the injected BROWSER_API_LOGGER (default: console).
      */
     logError(message, error) {
-        console.error(`[${this.getApiName()}] ${message}`, error);
+        this.logger.error(`[${this.getApiName()}] ${message}`, error);
+    }
+    /**
+     * Log a warning through the injected BROWSER_API_LOGGER (default: console).
+     */
+    logWarn(message) {
+        this.logger.warn(`[${this.getApiName()}] ${message}`);
     }
     /**
-     * Log an informational message with the service name as prefix.
+     * Log an informational message through the injected BROWSER_API_LOGGER (default: console).
      */
     logInfo(message) {
-        console.info(`[${this.getApiName()}] ${message}`);
+        this.logger.info(`[${this.getApiName()}] ${message}`);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserApiBaseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserApiBaseService });
@@ -94,59 +90,54 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-/**
- * Extension of `BrowserApiBaseService` for services that need to query
- * browser permissions via the Permissions API.
- *
- * Only services that actively call `requestPermission()` should extend this
- * class. All other services should extend `BrowserApiBaseService` directly
- * to avoid carrying an unnecessary PermissionsService dependency.
- */
-class PermissionAwareBrowserApiBaseService extends BrowserApiBaseService {
-    permissionsService = inject(PermissionsService);
-    /**
-     * Query the Permissions API for the given permission name.
-     * Returns `true` if the permission state is `'granted'`.
-     */
-    async requestPermission(permission) {
-        if (this.isServerEnvironment()) {
-            throw new Error(`${this.getApiName()} API not available in server environment`);
+class PermissionsService extends BrowserApiBaseService {
+    getApiName() {
+        return 'permissions';
+    }
+    async query(descriptor) {
+        if (!this.isSupported()) {
+            throw new Error('Permissions API not supported in this environment');
         }
         try {
-            const status = await this.permissionsService.query({ name: permission });
-            return status.state === 'granted';
+            return await navigator.permissions.query(descriptor);
         }
         catch (error) {
-            this.logError(`Error requesting permission for ${permission}:`, error);
-            return false;
+            // Firefox does not support querying 'camera', 'microphone', or 'speaker' via
+            // the Permissions API and throws a TypeError. Return a synthetic 'prompt' status
+            // so callers fall through to the native getUserMedia / requestPermission flow.
+            if (error instanceof TypeError) {
+                return { state: 'prompt', onchange: null };
+            }
+            this.logError(`Error querying permission for ${descriptor.name}:`, error);
+            throw error;
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionAwareBrowserApiBaseService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionAwareBrowserApiBaseService });
+    isSupported() {
+        return this.isBrowserEnvironment() && 'permissions' in navigator;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionAwareBrowserApiBaseService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService, decorators: [{
             type: Injectable
         }] });
 
-class CameraService extends PermissionAwareBrowserApiBaseService {
+class CameraService extends BrowserApiBaseService {
     currentStream = null;
     getApiName() {
         return 'camera';
     }
-    ensureCameraSupport() {
-        if (!('mediaDevices' in navigator) || !('getUserMedia' in navigator.mediaDevices)) {
-            throw new Error('Camera API not supported in this browser');
+    ensureSupported() {
+        super.ensureSupported();
+        if (!navigator.mediaDevices?.getUserMedia) {
+            throw new Error('Camera API not supported — a secure context (HTTPS) is required');
         }
     }
     async startCamera(constraints) {
-        this.ensureCameraSupport();
+        this.ensureSupported();
         if (this.currentStream) {
             this.stopCamera();
         }
-        const permissionStatus = await this.permissionsService.query({ name: 'camera' });
-        if (permissionStatus.state !== 'granted') {
-            throw new Error('Camera permission required. Please grant camera access and try again.');
-        }
         try {
             const streamConstraints = constraints || {
                 video: {
@@ -159,7 +150,7 @@ class CameraService extends PermissionAwareBrowserApiBaseService {
             return this.currentStream;
         }
         catch (error) {
-            console.error('[CameraService] Error starting camera:', error);
+            this.logError('Error starting camera:', error);
             if (error instanceof Error && error.name === 'NotAllowedError') {
                 throw this.createError('Camera permission denied by user. Please allow camera access in your browser settings and refresh the page.', error);
             }
@@ -201,19 +192,24 @@ class CameraService extends PermissionAwareBrowserApiBaseService {
         return this.startCamera(finalConstraints);
     }
     async getCameraCapabilities(deviceId) {
-        this.ensureCameraSupport();
+        this.ensureSupported();
         try {
+            const activeTrack = this.currentStream
+                ?.getVideoTracks()
+                .find((t) => t.getSettings().deviceId === deviceId);
+            if (activeTrack) {
+                return activeTrack.getCapabilities() ?? null;
+            }
             const stream = await navigator.mediaDevices.getUserMedia({
                 video: { deviceId: { exact: deviceId } },
             });
             const videoTrack = stream.getVideoTracks()[0];
             const capabilities = videoTrack.getCapabilities();
-            // Clean up the stream
             stream.getTracks().forEach((track) => track.stop());
-            return capabilities || null;
+            return capabilities ?? null;
         }
         catch (error) {
-            console.error('[CameraService] Error getting camera capabilities:', error);
+            this.logError('Error getting camera capabilities:', error);
             return null;
         }
     }
@@ -224,19 +220,19 @@ class CameraService extends PermissionAwareBrowserApiBaseService {
         return this.currentStream !== null;
     }
     async getVideoInputDevices() {
-        this.ensureCameraSupport();
+        this.ensureSupported();
         try {
             const devices = await navigator.mediaDevices.enumerateDevices();
             return devices.filter((device) => device.kind === 'videoinput');
         }
         catch (error) {
-            console.error('[CameraService] Error enumerating video devices:', error);
+            this.logError('Error enumerating video devices:', error);
             throw this.createError('Failed to enumerate video devices', error);
         }
     }
     // Direct access to native camera API
     getNativeMediaDevices() {
-        this.ensureCameraSupport();
+        this.ensureSupported();
         return navigator.mediaDevices;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CameraService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
@@ -250,13 +246,14 @@ class GeolocationService extends BrowserApiBaseService {
     getApiName() {
         return 'geolocation';
     }
-    ensureGeolocationSupport() {
+    ensureSupported() {
+        super.ensureSupported();
         if (!('geolocation' in navigator)) {
-            throw new Error('Geolocation API not supported in this browser');
+            throw new Error('Geolocation API not supported — a secure context (HTTPS) is required');
         }
     }
     getCurrentPosition(options) {
-        this.ensureGeolocationSupport();
+        this.ensureSupported();
         return new Promise((resolve, reject) => {
             navigator.geolocation.getCurrentPosition((position) => resolve(position), (error) => {
                 this.logError('Error getting position:', error);
@@ -265,7 +262,7 @@ class GeolocationService extends BrowserApiBaseService {
         });
     }
     watchPosition(options) {
-        this.ensureGeolocationSupport();
+        this.ensureSupported();
         return new Observable((observer) => {
             const watchId = navigator.geolocation.watchPosition((position) => observer.next(position), (error) => {
                 this.logError('Error watching position:', error);
@@ -281,7 +278,7 @@ class GeolocationService extends BrowserApiBaseService {
     }
     // Direct access to native geolocation API
     getNativeGeolocation() {
-        this.ensureGeolocationSupport();
+        this.ensureSupported();
         return navigator.geolocation;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GeolocationService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
@@ -295,24 +292,25 @@ class MediaDevicesService extends BrowserApiBaseService {
     getApiName() {
         return 'media-devices';
     }
-    ensureMediaDevicesSupport() {
-        if (!('mediaDevices' in navigator)) {
-            throw new Error('MediaDevices API not supported in this browser');
+    ensureSupported() {
+        super.ensureSupported();
+        if (!navigator.mediaDevices) {
+            throw new Error('MediaDevices API not supported — a secure context (HTTPS) is required');
         }
     }
     async getDevices() {
-        this.ensureMediaDevicesSupport();
+        this.ensureSupported();
         try {
             const devices = await navigator.mediaDevices.enumerateDevices();
             return devices;
         }
         catch (error) {
-            console.error('[MediaDevicesService] Error enumerating devices:', error);
+            this.logError('Error enumerating devices:', error);
             throw this.createError('Failed to enumerate media devices', error);
         }
     }
     async getUserMedia(constraints) {
-        this.ensureMediaDevicesSupport();
+        this.ensureSupported();
         try {
             const defaultConstraints = {
                 video: true,
@@ -322,12 +320,12 @@ class MediaDevicesService extends BrowserApiBaseService {
             return await navigator.mediaDevices.getUserMedia(finalConstraints);
         }
         catch (error) {
-            console.error('[MediaDevicesService] Error getting user media:', error);
+            this.logError('Error getting user media:', error);
             throw this.handleMediaError(error);
         }
     }
     async getDisplayMedia(constraints) {
-        this.ensureMediaDevicesSupport();
+        this.ensureSupported();
         if (!('getDisplayMedia' in navigator.mediaDevices)) {
             throw new Error('Display media API not supported in this browser');
         }
@@ -340,12 +338,12 @@ class MediaDevicesService extends BrowserApiBaseService {
             return await navigator.mediaDevices.getDisplayMedia(finalConstraints);
         }
         catch (error) {
-            console.error('[MediaDevicesService] Error getting display media:', error);
+            this.logError('Error getting display media:', error);
             throw this.createError('Failed to get display media', error);
         }
     }
     watchDeviceChanges() {
-        this.ensureMediaDevicesSupport();
+        this.ensureSupported();
         return new Observable((observer) => {
             const handleDeviceChange = async () => {
                 try {
@@ -353,7 +351,7 @@ class MediaDevicesService extends BrowserApiBaseService {
                     observer.next(devices);
                 }
                 catch (error) {
-                    console.error('[MediaDevicesService] Error handling device change:', error);
+                    this.logError('Error handling device change:', error);
                 }
             };
             // Listen for device changes
@@ -408,7 +406,7 @@ class MediaDevicesService extends BrowserApiBaseService {
     }
     // Direct access to native media devices API
     getNativeMediaDevices() {
-        this.ensureMediaDevicesSupport();
+        this.ensureSupported();
         return navigator.mediaDevices;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: MediaDevicesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
@@ -422,22 +420,24 @@ class NotificationService extends BrowserApiBaseService {
     getApiName() {
         return 'notifications';
     }
+    ensureSupported() {
+        super.ensureSupported();
+        if (!('Notification' in window)) {
+            throw new Error('Notifications API not supported in this browser');
+        }
+    }
     get permission() {
+        if (!this.isBrowserEnvironment() || !('Notification' in window)) {
+            return 'default';
+        }
         return Notification.permission;
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'Notification' in window;
-    }
     async requestNotificationPermission() {
-        if (!this.isSupported()) {
-            throw new Error('Notification API not supported in this browser');
-        }
+        this.ensureSupported();
         return Notification.requestPermission();
     }
     async showNotification(title, options) {
-        if (!this.isSupported()) {
-            throw new Error('Notification API not supported in this browser');
-        }
+        this.ensureSupported();
         if (Notification.permission !== 'granted') {
             throw new Error('Notification permission required. Please grant notification access and try again.');
         }
@@ -456,38 +456,33 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-class ClipboardService extends PermissionAwareBrowserApiBaseService {
+class ClipboardService extends BrowserApiBaseService {
     getApiName() {
         return 'clipboard';
     }
-    async ensureClipboardPermission(action) {
-        if (!('clipboard' in navigator)) {
-            throw new Error('Clipboard API not supported in this browser');
-        }
-        const permissionStatus = await this.permissionsService.query({
-            name: `clipboard-${action}`,
-        });
-        if (permissionStatus.state !== 'granted') {
-            throw new Error(`Clipboard ${action} permission required. Please grant clipboard access and try again.`);
+    ensureSupported() {
+        super.ensureSupported();
+        if (!navigator.clipboard) {
+            throw new Error('Clipboard API not supported \u2014 a secure context (HTTPS) is required');
         }
     }
     async writeText(text) {
-        await this.ensureClipboardPermission('write');
+        this.ensureSupported();
         try {
             await navigator.clipboard.writeText(text);
         }
         catch (error) {
-            console.error('[ClipboardService] Error writing to clipboard:', error);
+            this.logError('Error writing to clipboard:', error);
             throw error;
         }
     }
     async readText() {
-        await this.ensureClipboardPermission('read');
+        this.ensureSupported();
         try {
             return await navigator.clipboard.readText();
         }
         catch (error) {
-            console.error('[ClipboardService] Error reading from clipboard:', error);
+            this.logError('Error reading from clipboard:', error);
             throw error;
         }
     }
@@ -659,14 +654,15 @@ class BatteryService extends BrowserApiBaseService {
     getApiName() {
         return 'battery';
     }
-    ensureBatterySupport() {
+    ensureSupported() {
+        super.ensureSupported();
         const nav = navigator;
         if (!('getBattery' in nav)) {
-            throw new Error('Battery API not supported in this browser');
+            throw new Error('Battery Status API not supported in this browser');
         }
     }
     async initialize() {
-        this.ensureBatterySupport();
+        this.ensureSupported();
         try {
             const nav = navigator;
             this.batteryManager = await nav.getBattery();
@@ -674,7 +670,7 @@ class BatteryService extends BrowserApiBaseService {
             return batteryInfo;
         }
         catch (error) {
-            console.error('[BatteryService] Error initializing battery API:', error);
+            this.logError('Error initializing battery API:', error);
             throw this.createError('Failed to initialize battery API', error);
         }
     }
@@ -743,19 +739,20 @@ class WebShareService extends BrowserApiBaseService {
     getApiName() {
         return 'web-share';
     }
-    ensureWebShareSupport() {
+    ensureSupported() {
+        super.ensureSupported();
         if (!('share' in navigator)) {
             throw new Error('Web Share API not supported in this browser');
         }
     }
     async share(data) {
-        this.ensureWebShareSupport();
+        this.ensureSupported();
         try {
             await navigator.share(data);
             return { shared: true };
         }
         catch (error) {
-            console.error('[WebShareService] Error sharing:', error);
+            this.logError('Error sharing:', error);
             const errorMessage = error instanceof Error ? error.message : 'Share failed';
             return { shared: false, error: errorMessage };
         }
@@ -772,7 +769,7 @@ class WebShareService extends BrowserApiBaseService {
     }
     // Direct access to native share API
     getNativeShare() {
-        this.ensureWebShareSupport();
+        this.ensureSupported();
         return navigator.share;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebShareService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
@@ -784,7 +781,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
 
 class WebStorageService extends BrowserApiBaseService {
     storageEvents = signal(null, ...(ngDevMode ? [{ debugName: "storageEvents" }] : /* istanbul ignore next */ []));
-    destroyRef = inject(DestroyRef);
     constructor() {
         super();
         this.setupEventListeners();
@@ -792,8 +788,9 @@ class WebStorageService extends BrowserApiBaseService {
     getApiName() {
         return 'storage';
     }
-    ensureStorageSupport() {
-        if (!this.isBrowserEnvironment() || typeof Storage === 'undefined') {
+    ensureSupported() {
+        super.ensureSupported();
+        if (typeof Storage === 'undefined') {
             throw new Error('Storage API not supported in this browser');
         }
     }
@@ -803,14 +800,13 @@ class WebStorageService extends BrowserApiBaseService {
                 .pipe(takeUntilDestroyed(this.destroyRef))
                 .subscribe((event) => {
                 const storageEvent = event;
-                if (storageEvent.key && storageEvent.newValue !== null) {
-                    this.storageEvents.set({
-                        key: storageEvent.key,
-                        newValue: this.deserializeValue(storageEvent.newValue),
-                        oldValue: storageEvent.oldValue ? this.deserializeValue(storageEvent.oldValue) : null,
-                        storageArea: storageEvent.storageArea === localStorage ? 'localStorage' : 'sessionStorage',
-                    });
-                }
+                const area = storageEvent.storageArea === localStorage ? 'localStorage' : 'sessionStorage';
+                this.storageEvents.set({
+                    key: storageEvent.key,
+                    newValue: storageEvent.newValue ? this.deserializeValue(storageEvent.newValue) : null,
+                    oldValue: storageEvent.oldValue ? this.deserializeValue(storageEvent.oldValue) : null,
+                    storageArea: area,
+                });
             });
         }
     }
@@ -837,50 +833,58 @@ class WebStorageService extends BrowserApiBaseService {
         const prefix = options?.prefix || '';
         return prefix ? `${prefix}:${key}` : key;
     }
+    emitStorageChange(fullKey, newValue, oldValue, area) {
+        this.storageEvents.set({ key: fullKey, newValue, oldValue, storageArea: area });
+    }
     // Local Storage Methods
     setLocalStorage(key, value, options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         try {
             const serializedValue = this.serializeValue(value, options);
             const fullKey = this.getKey(key, options);
+            const oldRaw = localStorage.getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
             localStorage.setItem(fullKey, serializedValue);
+            this.emitStorageChange(fullKey, value, oldValue, 'localStorage');
             return true;
         }
         catch (error) {
-            console.error('[WebStorageService] Error setting localStorage:', error);
+            this.logError('Error setting localStorage:', error);
             return false;
         }
     }
     getLocalStorage(key, defaultValue = null, options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         try {
             const fullKey = this.getKey(key, options);
             const value = localStorage.getItem(fullKey);
             return value !== null ? this.deserializeValue(value, options) : defaultValue;
         }
         catch (error) {
-            console.error('[WebStorageService] Error getting localStorage:', error);
+            this.logError('Error getting localStorage:', error);
             return defaultValue;
         }
     }
     removeLocalStorage(key, options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         try {
             const fullKey = this.getKey(key, options);
+            const oldRaw = localStorage.getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
             localStorage.removeItem(fullKey);
+            this.emitStorageChange(fullKey, null, oldValue, 'localStorage');
             return true;
         }
         catch (error) {
-            console.error('[WebStorageService] Error removing localStorage:', error);
+            this.logError('Error removing localStorage:', error);
             return false;
         }
     }
     clearLocalStorage(options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         try {
             const prefix = options?.prefix;
             if (prefix) {
-                // Only remove keys with the specified prefix
                 const keysToRemove = [];
                 for (let i = 0; i < localStorage.length; i++) {
                     const key = localStorage.key(i);
@@ -888,62 +892,72 @@ class WebStorageService extends BrowserApiBaseService {
                         keysToRemove.push(key);
                     }
                 }
-                keysToRemove.forEach((key) => localStorage.removeItem(key));
+                keysToRemove.forEach((key) => {
+                    const oldRaw = localStorage.getItem(key);
+                    localStorage.removeItem(key);
+                    this.emitStorageChange(key, null, oldRaw, 'localStorage');
+                });
             }
             else {
                 localStorage.clear();
+                this.emitStorageChange(null, null, null, 'localStorage');
             }
             return true;
         }
         catch (error) {
-            console.error('[WebStorageService] Error clearing localStorage:', error);
+            this.logError('Error clearing localStorage:', error);
             return false;
         }
     }
     // Session Storage Methods
     setSessionStorage(key, value, options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         try {
             const serializedValue = this.serializeValue(value, options);
             const fullKey = this.getKey(key, options);
+            const oldRaw = sessionStorage.getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
             sessionStorage.setItem(fullKey, serializedValue);
+            this.emitStorageChange(fullKey, value, oldValue, 'sessionStorage');
             return true;
         }
         catch (error) {
-            console.error('[WebStorageService] Error setting sessionStorage:', error);
+            this.logError('Error setting sessionStorage:', error);
             return false;
         }
     }
     getSessionStorage(key, defaultValue = null, options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         try {
             const fullKey = this.getKey(key, options);
             const value = sessionStorage.getItem(fullKey);
             return value !== null ? this.deserializeValue(value, options) : defaultValue;
         }
         catch (error) {
-            console.error('[WebStorageService] Error getting sessionStorage:', error);
+            this.logError('Error getting sessionStorage:', error);
             return defaultValue;
         }
     }
     removeSessionStorage(key, options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         try {
             const fullKey = this.getKey(key, options);
+            const oldRaw = sessionStorage.getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
             sessionStorage.removeItem(fullKey);
+            this.emitStorageChange(fullKey, null, oldValue, 'sessionStorage');
             return true;
         }
         catch (error) {
-            console.error('[WebStorageService] Error removing sessionStorage:', error);
+            this.logError('Error removing sessionStorage:', error);
             return false;
         }
     }
     clearSessionStorage(options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         try {
             const prefix = options?.prefix;
             if (prefix) {
-                // Only remove keys with the specified prefix
                 const keysToRemove = [];
                 for (let i = 0; i < sessionStorage.length; i++) {
                     const key = sessionStorage.key(i);
@@ -951,21 +965,26 @@ class WebStorageService extends BrowserApiBaseService {
                         keysToRemove.push(key);
                     }
                 }
-                keysToRemove.forEach((key) => sessionStorage.removeItem(key));
+                keysToRemove.forEach((key) => {
+                    const oldRaw = sessionStorage.getItem(key);
+                    sessionStorage.removeItem(key);
+                    this.emitStorageChange(key, null, oldRaw, 'sessionStorage');
+                });
             }
             else {
                 sessionStorage.clear();
+                this.emitStorageChange(null, null, null, 'sessionStorage');
             }
             return true;
         }
         catch (error) {
-            console.error('[WebStorageService] Error clearing sessionStorage:', error);
+            this.logError('Error clearing sessionStorage:', error);
             return false;
         }
     }
     // Utility Methods
     getLocalStorageSize(options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         let totalSize = 0;
         const prefix = options?.prefix;
         for (let i = 0; i < localStorage.length; i++) {
@@ -977,7 +996,7 @@ class WebStorageService extends BrowserApiBaseService {
         return totalSize;
     }
     getSessionStorageSize(options = {}) {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         let totalSize = 0;
         const prefix = options?.prefix;
         for (let i = 0; i < sessionStorage.length; i++) {
@@ -994,30 +1013,20 @@ class WebStorageService extends BrowserApiBaseService {
             prev.oldValue === curr.oldValue));
     }
     watchLocalStorage(key, options = {}) {
-        return this.getStorageEvents().pipe(map((event) => {
-            const fullKey = this.getKey(key, options);
-            if (event.key === fullKey && event.storageArea === 'localStorage') {
-                return event.newValue;
-            }
-            return this.getLocalStorage(key, null, options);
-        }));
+        const fullKey = this.getKey(key, options);
+        return this.getStorageEvents().pipe(filter((event) => event.storageArea === 'localStorage' && (event.key === null || event.key === fullKey)), map((event) => event.newValue));
     }
     watchSessionStorage(key, options = {}) {
-        return this.getStorageEvents().pipe(map((event) => {
-            const fullKey = this.getKey(key, options);
-            if (event.key === fullKey && event.storageArea === 'sessionStorage') {
-                return event.newValue;
-            }
-            return this.getSessionStorage(key, null, options);
-        }));
+        const fullKey = this.getKey(key, options);
+        return this.getStorageEvents().pipe(filter((event) => event.storageArea === 'sessionStorage' && (event.key === null || event.key === fullKey)), map((event) => event.newValue));
     }
     // Direct access to native storage APIs
     getNativeLocalStorage() {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         return localStorage;
     }
     getNativeSessionStorage() {
-        this.ensureStorageSupport();
+        this.ensureSupported();
         return sessionStorage;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -1027,229 +1036,480 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }], ctorParameters: () => [] });
 
-class WebSocketService extends BrowserApiBaseService {
-    webSocket = null;
-    statusSubject = new Subject();
-    messageSubject = new Subject();
-    reconnectAttempts = 0;
+const DEFAULT_MAX_RECONNECT_DELAY = 30_000;
+const DEFAULT_REQUEST_TIMEOUT = 30_000;
+/**
+ * Stateful WebSocket client wrapping a single connection. One instance per logical
+ * connection (do NOT share between `connect()` calls).
+ *
+ * Surfaces:
+ * - `status`: signal of the current connection state.
+ * - `messages$`: stream of every received message (parsed JSON).
+ * - `send` / `sendRaw`: outbound traffic.
+ * - `request<T>(type, data)`: round-trip with id correlation and timeout.
+ * - `close`: idempotent disposal.
+ *
+ * Reconnect uses exponential backoff with jitter, capped by `maxReconnectDelay`.
+ */
+class WebSocketClient {
+    config;
+    logger;
+    socket = null;
     reconnectTimer = null;
     heartbeatTimer = null;
-    getApiName() {
-        return 'websocket';
-    }
-    ensureWebSocketSupport() {
-        if (typeof WebSocket === 'undefined') {
-            throw new Error('WebSocket API not supported in this browser');
+    _status;
+    _messages$ = new Subject();
+    pendingRequests = new Map();
+    disposed = false;
+    reconnectAttempts = 0;
+    constructor(config, logger, destroyRef) {
+        this.config = config;
+        this.logger = logger;
+        this._status = signal({
+            state: 'idle',
+            reconnectAttempts: 0,
+            error: null,
+        }, ...(ngDevMode ? [{ debugName: "_status" }] : /* istanbul ignore next */ []));
+        if (destroyRef) {
+            destroyRef.onDestroy(() => this.close());
         }
+        this.openSocket();
     }
-    connect(config) {
-        this.ensureWebSocketSupport();
-        return new Observable((observer) => {
-            this.disconnect(); // Disconnect existing connection if any
-            this.updateStatus({
-                connected: false,
-                connecting: true,
-                reconnecting: false,
-                reconnectAttempts: 0,
-            });
-            try {
-                this.webSocket = new WebSocket(config.url, config.protocols);
-                this.setupWebSocketHandlers(config);
-                observer.next(this.getCurrentStatus());
-            }
-            catch (error) {
-                console.error('[WebSocketService] Error creating WebSocket:', error);
-                this.updateStatus({
-                    connected: false,
-                    connecting: false,
-                    reconnecting: false,
-                    error: error instanceof Error ? error.message : 'Connection failed',
-                    reconnectAttempts: 0,
-                });
-                observer.next(this.getCurrentStatus());
-            }
-            return () => {
-                this.disconnect();
-            };
-        });
+    get status() {
+        return this._status.asReadonly();
     }
-    disconnect() {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-        if (this.webSocket) {
-            this.webSocket.close();
-            this.webSocket = null;
-        }
-        this.updateStatus({
-            connected: false,
-            connecting: false,
-            reconnecting: false,
-            reconnectAttempts: 0,
-        });
+    get messages$() {
+        return this._messages$.asObservable();
+    }
+    messagesByType(type) {
+        return this._messages$
+            .asObservable()
+            .pipe(filter((msg) => msg.type === type));
     }
     send(message) {
-        if (!this.webSocket || this.webSocket.readyState !== WebSocket.OPEN) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
             throw new Error('WebSocket is not connected');
         }
-        const messageWithTimestamp = {
+        const enriched = {
             ...message,
-            timestamp: Date.now(),
+            id: message.id ?? this.generateId(),
+            timestamp: message.timestamp ?? Date.now(),
         };
-        this.webSocket.send(JSON.stringify(messageWithTimestamp));
+        this.socket.send(JSON.stringify(enriched));
     }
     sendRaw(data) {
-        if (!this.webSocket || this.webSocket.readyState !== WebSocket.OPEN) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
             throw new Error('WebSocket is not connected');
         }
-        this.webSocket.send(data);
+        this.socket.send(data);
     }
-    getStatus() {
-        return this.statusSubject.asObservable();
+    /**
+     * Send a message and await a correlated response. The server MUST echo back the
+     * `correlationId` from the request as `correlationId` on the response message.
+     */
+    request(type, data, opts) {
+        const id = this.generateId();
+        const timeoutMs = opts?.timeout ?? DEFAULT_REQUEST_TIMEOUT;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`WebSocket request timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pendingRequests.set(id, {
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            try {
+                this.send({ id, type, data, correlationId: id });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(error instanceof Error ? error : new Error('WebSocket send failed'));
+            }
+        });
     }
-    getMessages() {
-        return this.messageSubject
-            .asObservable()
-            .pipe(filter((msg) => true));
+    close() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.clearTimers();
+        if (this.socket) {
+            try {
+                this.socket.close();
+            }
+            catch {
+                // Ignore — already closing.
+            }
+            this.socket = null;
+        }
+        this.rejectAllPending(new Error('WebSocket closed'));
+        this.updateStatus({ state: 'closed', error: null });
+    }
+    /** Internal handle for tests and advanced usage. */
+    getNativeSocket() {
+        return this.socket;
+    }
+    // ---------- internals ----------
+    openSocket() {
+        if (this.disposed)
+            return;
+        this.updateStatus({ state: 'connecting', error: null });
+        try {
+            this.socket = new WebSocket(this.config.url, this.config.protocols);
+            this.attachHandlers();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'WebSocket open failed';
+            this.logger.error('[websocket] Failed to construct socket', error);
+            this.updateStatus({ state: 'closed', error: message });
+            this.scheduleReconnect();
+        }
     }
-    setupWebSocketHandlers(config) {
-        if (!this.webSocket)
+    attachHandlers() {
+        if (!this.socket)
             return;
-        this.webSocket.onopen = () => {
-            console.log('[WebSocketService] Connected to:', config.url);
+        this.socket.onopen = () => {
             this.reconnectAttempts = 0;
-            this.updateStatus({
-                connected: true,
-                connecting: false,
-                reconnecting: false,
-                reconnectAttempts: 0,
-            });
-            // Start heartbeat if configured
-            if (config.heartbeatInterval && config.heartbeatMessage) {
-                this.startHeartbeat(config);
-            }
+            this.updateStatus({ state: 'open', error: null, reconnectAttempts: 0 });
+            this.startHeartbeat();
         };
-        this.webSocket.onclose = (event) => {
-            console.log('[WebSocketService] Connection closed:', event.code, event.reason);
+        this.socket.onclose = (event) => {
+            this.stopHeartbeat();
+            if (this.disposed)
+                return;
             this.updateStatus({
-                connected: false,
-                connecting: false,
-                reconnecting: false,
-                reconnectAttempts: this.reconnectAttempts,
+                state: 'closed',
+                error: event.wasClean ? null : `closed: ${event.code} ${event.reason}`,
             });
-            // Attempt reconnection if not a clean close and reconnect is enabled
-            if (!event.wasClean && config.reconnectInterval && config.maxReconnectAttempts) {
-                this.attemptReconnect(config);
+            if (!event.wasClean) {
+                this.scheduleReconnect();
             }
         };
-        this.webSocket.onerror = (error) => {
-            console.error('[WebSocketService] WebSocket error:', error);
-            this.updateStatus({
-                connected: false,
-                connecting: false,
-                reconnecting: false,
-                error: 'WebSocket connection error',
-                reconnectAttempts: this.reconnectAttempts,
-            });
+        this.socket.onerror = () => {
+            this.updateStatus({ error: 'WebSocket connection error' });
         };
-        this.webSocket.onmessage = (event) => {
-            try {
-                const message = JSON.parse(event.data);
-                this.messageSubject.next(message);
-            }
-            catch (error) {
-                console.error('[WebSocketService] Error parsing message:', error);
-            }
+        this.socket.onmessage = (event) => {
+            this.handleIncoming(event.data);
         };
     }
-    startHeartbeat(config) {
-        this.heartbeatTimer = setInterval(() => {
-            if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                this.send({
-                    type: 'heartbeat',
-                    data: config.heartbeatMessage,
-                });
-            }
-        }, config.heartbeatInterval);
+    handleIncoming(raw) {
+        let message;
+        try {
+            const text = typeof raw === 'string' ? raw : String(raw);
+            message = JSON.parse(text);
+        }
+        catch (error) {
+            this.logger.warn('[websocket] Failed to parse incoming message');
+            this.logger.error('[websocket] parse error', error);
+            return;
+        }
+        const correlationId = message.correlationId ?? message.id;
+        if (correlationId && this.pendingRequests.has(correlationId)) {
+            const pending = this.pendingRequests.get(correlationId);
+            clearTimeout(pending.timer);
+            this.pendingRequests.delete(correlationId);
+            pending.resolve(message.data);
+            return;
+        }
+        this._messages$.next(message);
     }
-    attemptReconnect(config) {
-        if (this.reconnectAttempts >= (config.maxReconnectAttempts || 5)) {
-            console.log('[WebSocketService] Max reconnect attempts reached');
+    scheduleReconnect() {
+        if (this.disposed)
+            return;
+        const interval = this.config.reconnectInterval ?? 0;
+        const maxAttempts = this.config.maxReconnectAttempts ?? 0;
+        if (interval <= 0 || maxAttempts <= 0)
+            return;
+        if (this.reconnectAttempts >= maxAttempts) {
+            this.updateStatus({
+                state: 'closed',
+                error: `Max reconnect attempts (${maxAttempts}) reached`,
+            });
             return;
         }
-        this.reconnectAttempts++;
+        this.reconnectAttempts += 1;
+        const delay = WebSocketClient.computeBackoffDelay(this.reconnectAttempts, interval, this.config.maxReconnectDelay ?? DEFAULT_MAX_RECONNECT_DELAY);
         this.updateStatus({
-            connected: false,
-            connecting: false,
-            reconnecting: true,
+            state: 'reconnecting',
             reconnectAttempts: this.reconnectAttempts,
         });
         this.reconnectTimer = setTimeout(() => {
-            console.log(`[WebSocketService] Reconnect attempt ${this.reconnectAttempts}`);
-            this.connect(config);
-        }, config.reconnectInterval || 3000);
+            this.reconnectTimer = null;
+            this.openSocket();
+        }, delay);
     }
-    updateStatus(status) {
-        const currentStatus = this.getCurrentStatus();
-        const newStatus = { ...currentStatus, ...status };
-        this.statusSubject.next(newStatus);
+    /**
+     * Exponential backoff with full jitter:
+     *   baseDelay = min(maxDelay, interval * 2^(attempt - 1))
+     *   delay     = random(0, baseDelay)
+     */
+    static computeBackoffDelay(attempt, interval, maxDelay) {
+        const exp = Math.min(maxDelay, interval * Math.pow(2, attempt - 1));
+        return Math.floor(Math.random() * exp);
     }
-    getCurrentStatus() {
-        return {
-            connected: this.webSocket?.readyState === WebSocket.OPEN,
-            connecting: false,
-            reconnecting: false,
-            reconnectAttempts: this.reconnectAttempts,
-        };
+    startHeartbeat() {
+        const { heartbeatInterval, heartbeatMessage } = this.config;
+        if (!heartbeatInterval || heartbeatMessage === undefined)
+            return;
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                try {
+                    this.send({ type: 'heartbeat', data: heartbeatMessage });
+                }
+                catch (error) {
+                    this.logger.warn('[websocket] heartbeat send failed');
+                    this.logger.error('[websocket] heartbeat error', error);
+                }
+            }
+        }, heartbeatInterval);
     }
-    // Direct access to native WebSocket
-    getNativeWebSocket() {
-        return this.webSocket;
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
     }
-    isConnected() {
-        return this.webSocket?.readyState === WebSocket.OPEN;
+    clearTimers() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.stopHeartbeat();
     }
-    getReadyState() {
-        return this.webSocket?.readyState ?? WebSocket.CLOSED;
+    rejectAllPending(reason) {
+        this.pendingRequests.forEach((entry) => {
+            clearTimeout(entry.timer);
+            entry.reject(reason);
+        });
+        this.pendingRequests.clear();
+    }
+    updateStatus(partial) {
+        this._status.update((current) => ({ ...current, ...partial }));
+    }
+    generateId() {
+        if (typeof globalThis.crypto?.randomUUID === 'function') {
+            return globalThis.crypto.randomUUID();
+        }
+        return `ws-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService, decorators: [{
-            type: Injectable
-        }] });
 
-class WebWorkerService extends BrowserApiBaseService {
-    destroyRef = inject(DestroyRef);
-    workers = new Map();
-    workerStatuses = new Map();
-    workerMessages = new Map();
-    currentWorkerStatuses = new Map();
+let legacyDeprecationLogged = false;
+/**
+ * Service that creates and tracks `WebSocketClient` instances.
+ *
+ * Preferred usage:
+ * ```ts
+ * const ws = inject(WebSocketService);
+ * const client = ws.createClient({ url: 'wss://...' });
+ * effect(() => console.log(client.status()));
+ * await client.request('ping', {});
+ * ```
+ *
+ * Legacy usage (`connect()` returning Observable) is preserved for one minor cycle
+ * and will be removed in v22.
+ */
+class WebSocketService extends BrowserApiBaseService {
+    wsLogger = inject(BROWSER_API_LOGGER);
+    clients = new Set();
+    _cleanup = this.destroyRef.onDestroy(() => this.disposeAll());
+    /** Legacy single-connection holder used by deprecated `connect()`/`send()` API. */
+    legacyClient = null;
     getApiName() {
-        return 'webworker';
+        return 'websocket';
     }
-    ensureWorkerSupport() {
-        if (typeof Worker === 'undefined') {
-            throw new Error('Web Workers not supported in this browser');
+    ensureSupported() {
+        super.ensureSupported();
+        if (typeof WebSocket === 'undefined') {
+            throw new Error('WebSocket API not supported in this browser');
         }
     }
-    createWorker(name, scriptUrl) {
-        this.ensureWorkerSupport();
+    /**
+     * Create a new WebSocket client. The client owns one connection and is the recommended
+     * surface for all interactions (status signal, request/response, reconnect, etc.).
+     *
+     * The returned client is automatically disposed when the host injector is destroyed.
+     */
+    createClient(config) {
+        this.ensureSupported();
+        const client = new WebSocketClient(config, this.wsLogger, this.destroyRef);
+        this.clients.add(client);
+        return client;
+    }
+    /** Dispose every client created via `createClient()` (also called automatically on destroy). */
+    disposeAll() {
+        for (const client of this.clients) {
+            client.close();
+        }
+        this.clients.clear();
+        if (this.legacyClient) {
+            this.legacyClient.close();
+            this.legacyClient = null;
+        }
+    }
+    // ---------- legacy API (deprecated) ----------
+    /**
+     * @deprecated Use {@link createClient} which returns a `WebSocketClient` exposing a
+     * status signal, request/response, and proper reconnect. This wrapper will be removed
+     * in v22.
+     */
+    connect(config) {
+        this.ensureSupported();
+        this.warnLegacyOnce();
         return new Observable((observer) => {
-            if (this.workers.has(name)) {
-                observer.next(this.currentWorkerStatuses.get(name));
+            if (this.legacyClient) {
+                this.legacyClient.close();
+            }
+            const client = new WebSocketClient(config, this.wsLogger);
+            this.legacyClient = client;
+            const sub = toObservableLike(client).subscribe({
+                next: (status) => observer.next(status),
+                error: (err) => observer.error(err),
+            });
+            return () => {
+                sub.unsubscribe();
+                client.close();
+                if (this.legacyClient === client) {
+                    this.legacyClient = null;
+                }
+            };
+        });
+    }
+    /** @deprecated Use {@link createClient} and call `client.close()`. */
+    disconnect() {
+        if (this.legacyClient) {
+            this.legacyClient.close();
+            this.legacyClient = null;
+        }
+    }
+    /** @deprecated Use the client returned by {@link createClient}. */
+    send(message) {
+        if (!this.legacyClient) {
+            throw new Error('No active legacy WebSocket. Call connect() first or use createClient().');
+        }
+        this.legacyClient.send(message);
+    }
+    /** @deprecated Use the client returned by {@link createClient}. */
+    sendRaw(data) {
+        if (!this.legacyClient) {
+            throw new Error('No active legacy WebSocket. Call connect() first or use createClient().');
+        }
+        this.legacyClient.sendRaw(data);
+    }
+    /** @deprecated Use `client.status` from {@link createClient}. */
+    getStatus() {
+        return new Observable((observer) => {
+            if (!this.legacyClient) {
+                observer.next({
+                    connected: false,
+                    connecting: false,
+                    reconnecting: false,
+                    reconnectAttempts: 0,
+                });
                 return () => {
-                    // No-op: workers are managed explicitly via terminateWorker/terminateAllWorkers
+                    // No-op
                 };
             }
-            try {
-                const worker = new Worker(scriptUrl);
-                this.workers.set(name, worker);
+            const sub = toObservableLike(this.legacyClient).subscribe((status) => observer.next(status));
+            return () => sub.unsubscribe();
+        });
+    }
+    /** @deprecated Use `client.messages$` from {@link createClient}. */
+    getMessages() {
+        if (!this.legacyClient) {
+            return new Observable(() => {
+                // No-op stream until connected.
+            });
+        }
+        return this.legacyClient.messages$;
+    }
+    /** @deprecated Use `client.messagesByType()` from {@link createClient}. */
+    getMessagesByType(type) {
+        if (!this.legacyClient) {
+            return new Observable(() => {
+                // No-op stream until connected.
+            });
+        }
+        return this.legacyClient.messagesByType(type);
+    }
+    /** @deprecated Use the client returned by {@link createClient}. */
+    getNativeWebSocket() {
+        return this.legacyClient?.getNativeSocket() ?? null;
+    }
+    /** @deprecated Use `client.status()` from {@link createClient}. */
+    isConnected() {
+        return this.legacyClient?.status().state === 'open';
+    }
+    /** @deprecated Use the native socket via `client.getNativeSocket()`. */
+    getReadyState() {
+        return this.legacyClient?.getNativeSocket()?.readyState ?? WebSocket.CLOSED;
+    }
+    warnLegacyOnce() {
+        if (legacyDeprecationLogged)
+            return;
+        legacyDeprecationLogged = true;
+        this.wsLogger.warn('[websocket] WebSocketService.connect() is deprecated. Use WebSocketService.createClient() ' +
+            'which returns a WebSocketClient with a status signal, request/response, and proper reconnect. ' +
+            'The legacy API will be removed in v22.');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Build a stream of legacy `WebSocketStatus` snapshots from a v2 client. Used to keep the
+ * deprecated `connect()` API behaving like before (Observable of legacy status).
+ */
+function toObservableLike(client) {
+    return new Observable((observer) => {
+        const emit = () => {
+            const v2 = client.status();
+            observer.next({
+                connected: v2.state === 'open',
+                connecting: v2.state === 'connecting',
+                reconnecting: v2.state === 'reconnecting',
+                error: v2.error ?? undefined,
+                reconnectAttempts: v2.reconnectAttempts,
+            });
+        };
+        emit();
+        const id = setInterval(emit, 100);
+        return () => clearInterval(id);
+    });
+}
+
+class WebWorkerService extends BrowserApiBaseService {
+    workers = new Map();
+    workerStatuses = new Map();
+    workerMessages = new Map();
+    currentWorkerStatuses = new Map();
+    _cleanup = this.destroyRef.onDestroy(() => this.terminateAllWorkers());
+    getApiName() {
+        return 'webworker';
+    }
+    ensureSupported() {
+        super.ensureSupported();
+        if (typeof Worker === 'undefined') {
+            throw new Error('Web Workers not supported in this browser');
+        }
+    }
+    createWorker(name, scriptUrl) {
+        this.ensureSupported();
+        return new Observable((observer) => {
+            if (this.workers.has(name)) {
+                observer.next(this.currentWorkerStatuses.get(name));
+                return () => {
+                    // No-op: workers are managed explicitly via terminateWorker/terminateAllWorkers
+                };
+            }
+            try {
+                const worker = new Worker(scriptUrl);
+                this.workers.set(name, worker);
                 this.setupWorker(name, worker);
                 const status = {
                     initialized: true,
@@ -1261,7 +1521,7 @@ class WebWorkerService extends BrowserApiBaseService {
                 observer.next(status);
             }
             catch (error) {
-                console.error(`[WebWorkerService] Failed to create worker ${name}:`, error);
+                this.logError(`Failed to create worker ${name}:`, error);
                 const status = {
                     initialized: false,
                     running: false,
@@ -1295,7 +1555,7 @@ class WebWorkerService extends BrowserApiBaseService {
     postMessage(workerName, task) {
         const worker = this.workers.get(workerName);
         if (!worker) {
-            console.error(`[WebWorkerService] Worker ${workerName} not found`);
+            this.logError(`Worker ${workerName} not found`);
             return;
         }
         try {
@@ -1313,7 +1573,7 @@ class WebWorkerService extends BrowserApiBaseService {
             }
         }
         catch (error) {
-            console.error(`[WebWorkerService] Failed to post message to worker ${workerName}:`, error);
+            this.logError(`Failed to post message to worker ${workerName}:`, error);
         }
     }
     getMessages(workerName) {
@@ -1352,7 +1612,7 @@ class WebWorkerService extends BrowserApiBaseService {
             this.workerMessages.get(name).next(message);
         };
         worker.onerror = (error) => {
-            console.error(`[WebWorkerService] Worker ${name} error:`, error);
+            this.logError(`Worker ${name} error:`, error);
             const status = {
                 initialized: true,
                 running: false,
@@ -1724,7 +1984,7 @@ class ScreenWakeLockService extends BrowserApiBaseService {
         return 'screen-wake-lock';
     }
     isSupported() {
-        return isPlatformBrowser(this.platformId) && 'wakeLock' in navigator;
+        return this.isBrowserEnvironment() && 'wakeLock' in navigator;
     }
     get isActive() {
         return this.sentinel !== null && !this.sentinel.released;
@@ -1745,7 +2005,7 @@ class ScreenWakeLockService extends BrowserApiBaseService {
             return { active: true, type, released: false };
         }
         catch (error) {
-            console.error('[ScreenWakeLockService] Failed to acquire wake lock:', error);
+            this.logError('Failed to acquire wake lock:', error);
             throw this.createError('Failed to acquire wake lock', error);
         }
     }
@@ -1961,10 +2221,8 @@ class FileSystemAccessService extends BrowserApiBaseService {
     get win() {
         return window;
     }
-    ensureSupport() {
-        if (this.isServerEnvironment()) {
-            throw new Error('File System Access API not available in server environment');
-        }
+    ensureSupported() {
+        super.ensureSupported();
         if (!('showOpenFilePicker' in window)) {
             throw new Error('File System Access API not supported in this browser');
         }
@@ -1973,7 +2231,7 @@ class FileSystemAccessService extends BrowserApiBaseService {
         }
     }
     async openFile(options = {}) {
-        this.ensureSupport();
+        this.ensureSupported();
         try {
             const handles = await this.win.showOpenFilePicker(options);
             return Promise.all(handles.map((h) => h.getFile()));
@@ -1982,12 +2240,12 @@ class FileSystemAccessService extends BrowserApiBaseService {
             if (error instanceof DOMException && error.name === 'AbortError') {
                 return [];
             }
-            console.error('[FileSystemAccessService] Error opening file:', error);
+            this.logError('Error opening file:', error);
             throw error;
         }
     }
     async saveFile(content, options = {}) {
-        this.ensureSupport();
+        this.ensureSupported();
         if (!this.win.showSaveFilePicker) {
             throw new Error('showSaveFilePicker not supported');
         }
@@ -2001,12 +2259,12 @@ class FileSystemAccessService extends BrowserApiBaseService {
             if (error instanceof DOMException && error.name === 'AbortError') {
                 return;
             }
-            console.error('[FileSystemAccessService] Error saving file:', error);
+            this.logError('Error saving file:', error);
             throw error;
         }
     }
     async openDirectory(options = {}) {
-        this.ensureSupport();
+        this.ensureSupported();
         if (!this.win.showDirectoryPicker) {
             throw new Error('showDirectoryPicker not supported');
         }
@@ -2017,7 +2275,7 @@ class FileSystemAccessService extends BrowserApiBaseService {
             if (error instanceof DOMException && error.name === 'AbortError') {
                 return null;
             }
-            console.error('[FileSystemAccessService] Error opening directory:', error);
+            this.logError('Error opening directory:', error);
             throw error;
         }
     }
@@ -2084,7 +2342,7 @@ class MediaRecorderService extends BrowserApiBaseService {
             this.recorder.start(timeslice);
         }
         catch (error) {
-            console.error('[MediaRecorderService] Failed to start recording:', error);
+            this.logError('Failed to start recording:', error);
             throw this.createError('Failed to start recording', error);
         }
     }
@@ -2170,7 +2428,7 @@ class ServerSentEventsService extends ConnectionRegistryBaseService {
                     observer.error(new Error('SSE connection closed unexpectedly'));
                 }
                 else {
-                    console.warn(`[${this.getApiName()}] SSE connection error, reconnecting...`, event);
+                    this.logWarn('SSE connection error, reconnecting...');
                 }
             };
             source.addEventListener('message', messageHandler);
@@ -2432,106 +2690,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-function getIdleDetectorClass$1() {
-    return window.IdleDetector;
-}
-class IdleDetectorService extends BrowserApiBaseService {
-    getApiName() {
-        return 'idle-detector';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'IdleDetector' in window;
-    }
-    async requestPermission() {
-        if (!this.isSupported()) {
-            throw new Error('IdleDetector API not supported');
-        }
-        return getIdleDetectorClass$1().requestPermission();
-    }
-    watch(options = {}) {
-        if (!this.isSupported()) {
-            return new Observable((o) => o.error(new Error('IdleDetector API not supported')));
-        }
-        return new Observable((subscriber) => {
-            const abortController = new AbortController();
-            const detector = new (getIdleDetectorClass$1())();
-            detector.addEventListener('change', () => {
-                subscriber.next({
-                    user: detector.userState,
-                    screen: detector.screenState,
-                });
-            });
-            detector
-                .start({
-                threshold: options.threshold ?? 60_000,
-                signal: abortController.signal,
-            })
-                .catch((err) => subscriber.error(err));
-            return () => abortController.abort();
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService, decorators: [{
-            type: Injectable
-        }] });
-
-function getEyeDropperClass() {
-    return window.EyeDropper;
-}
-class EyeDropperService extends BrowserApiBaseService {
-    getApiName() {
-        return 'eye-dropper';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'EyeDropper' in window;
-    }
-    async open(signal) {
-        if (!this.isSupported()) {
-            throw new Error('EyeDropper API not supported');
-        }
-        const dropper = new (getEyeDropperClass())();
-        return dropper.open(signal ? { signal } : undefined);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService, decorators: [{
-            type: Injectable
-        }] });
-
-function getBarcodeDetectorClass() {
-    return window.BarcodeDetector;
-}
-class BarcodeDetectorService extends BrowserApiBaseService {
-    getApiName() {
-        return 'barcode-detector';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'BarcodeDetector' in window;
-    }
-    async getSupportedFormats() {
-        if (!this.isSupported())
-            return [];
-        return getBarcodeDetectorClass().getSupportedFormats();
-    }
-    async detect(image, formats) {
-        if (!this.isSupported()) {
-            throw new Error('BarcodeDetector API not supported');
-        }
-        const detector = formats
-            ? new (getBarcodeDetectorClass())({ formats })
-            : new (getBarcodeDetectorClass())();
-        return detector.detect(image);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService, decorators: [{
-            type: Injectable
-        }] });
-
 class WebAudioService extends BrowserApiBaseService {
     getApiName() {
         return 'web-audio';
@@ -2741,301 +2899,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-function getBluetooth() {
-    return navigator.bluetooth;
-}
-class WebBluetoothService extends BrowserApiBaseService {
-    getApiName() {
-        return 'web-bluetooth';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && !!getBluetooth();
-    }
-    async requestDevice(options = { acceptAllDevices: true }) {
-        if (!this.isSupported()) {
-            throw new Error('Web Bluetooth API not supported');
-        }
-        return getBluetooth().requestDevice(options);
-    }
-    async connect(device) {
-        if (!device.gatt) {
-            throw new Error('GATT server not available on this device');
-        }
-        return device.gatt.connect();
-    }
-    disconnect(device) {
-        device.gatt?.disconnect();
-    }
-    watchDisconnection(device) {
-        return new Observable((subscriber) => {
-            const handler = () => subscriber.next();
-            device.addEventListener('gattserverdisconnected', handler);
-            return () => device.removeEventListener('gattserverdisconnected', handler);
-        });
-    }
-    async readCharacteristic(server, serviceUuid, characteristicUuid) {
-        const service = await server.getPrimaryService(serviceUuid);
-        const characteristic = await service.getCharacteristic(characteristicUuid);
-        return characteristic.readValue();
-    }
-    async writeCharacteristic(server, serviceUuid, characteristicUuid, value) {
-        const service = await server.getPrimaryService(serviceUuid);
-        const characteristic = await service.getCharacteristic(characteristicUuid);
-        await characteristic.writeValue(value);
-    }
-    watchCharacteristic(server, serviceUuid, characteristicUuid) {
-        return new Observable((subscriber) => {
-            let characteristic;
-            server
-                .getPrimaryService(serviceUuid)
-                .then((service) => service.getCharacteristic(characteristicUuid))
-                .then((char) => {
-                characteristic = char;
-                const handler = (event) => {
-                    const target = event.target;
-                    if (target.value)
-                        subscriber.next(target.value);
-                };
-                characteristic.addEventListener('characteristicvaluechanged', handler);
-                return characteristic.startNotifications();
-            })
-                .catch((err) => subscriber.error(err));
-            return () => {
-                characteristic?.stopNotifications().catch(() => { });
-            };
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService, decorators: [{
-            type: Injectable
-        }] });
-
-function getUsb() {
-    return navigator.usb;
-}
-class WebUsbService extends BrowserApiBaseService {
-    getApiName() {
-        return 'web-usb';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && !!getUsb();
-    }
-    async requestDevice(filters = []) {
-        if (!this.isSupported()) {
-            throw new Error('WebUSB API not supported');
-        }
-        return getUsb().requestDevice({ filters });
-    }
-    async getDevices() {
-        if (!this.isSupported())
-            return [];
-        return getUsb().getDevices();
-    }
-    async open(device) {
-        await device.open();
-    }
-    async close(device) {
-        await device.close();
-    }
-    async selectConfiguration(device, configurationValue) {
-        await device.selectConfiguration(configurationValue);
-    }
-    async claimInterface(device, interfaceNumber) {
-        await device.claimInterface(interfaceNumber);
-    }
-    async releaseInterface(device, interfaceNumber) {
-        await device.releaseInterface(interfaceNumber);
-    }
-    async transferIn(device, endpointNumber, length) {
-        return device.transferIn(endpointNumber, length);
-    }
-    async transferOut(device, endpointNumber, data) {
-        return device.transferOut(endpointNumber, data);
-    }
-    watchConnection() {
-        if (!this.isSupported()) {
-            return new Observable((o) => o.error(new Error('WebUSB API not supported')));
-        }
-        return new Observable((subscriber) => {
-            const usb = getUsb();
-            const onConnect = (e) => subscriber.next({ device: e.device, type: 'connect' });
-            const onDisconnect = (e) => subscriber.next({ device: e.device, type: 'disconnect' });
-            usb.addEventListener('connect', onConnect);
-            usb.addEventListener('disconnect', onDisconnect);
-            return () => {
-                usb.removeEventListener('connect', onConnect);
-                usb.removeEventListener('disconnect', onDisconnect);
-            };
-        });
-    }
-    getDeviceInfo(device) {
-        return {
-            vendorId: device.vendorId,
-            productId: device.productId,
-            productName: device.productName,
-            manufacturerName: device.manufacturerName,
-            serialNumber: device.serialNumber,
-            opened: device.opened,
-        };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService, decorators: [{
-            type: Injectable
-        }] });
-
-function getNdefReaderClass() {
-    return window.NDEFReader;
-}
-class WebNfcService extends BrowserApiBaseService {
-    getApiName() {
-        return 'web-nfc';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'NDEFReader' in window;
-    }
-    scan() {
-        if (!this.isSupported()) {
-            return new Observable((o) => o.error(new Error('Web NFC API not supported')));
-        }
-        return new Observable((subscriber) => {
-            const abortController = new AbortController();
-            const reader = new (getNdefReaderClass())();
-            const onReading = (event) => {
-                const e = event;
-                subscriber.next({
-                    serialNumber: e.serialNumber,
-                    message: e.message,
-                });
-            };
-            const onError = (event) => {
-                subscriber.error(event.error ?? new Error('NFC read error'));
-            };
-            reader.addEventListener('reading', onReading);
-            reader.addEventListener('readingerror', onError);
-            reader
-                .scan({ signal: abortController.signal })
-                .catch((err) => subscriber.error(err));
-            return () => abortController.abort();
-        });
-    }
-    async write(message, options) {
-        if (!this.isSupported()) {
-            throw new Error('Web NFC API not supported');
-        }
-        const reader = new (getNdefReaderClass())();
-        await reader.write(message, options);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService, decorators: [{
-            type: Injectable
-        }] });
-
-class PaymentRequestService extends BrowserApiBaseService {
-    getApiName() {
-        return 'payment-request';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'PaymentRequest' in window;
-    }
-    async canMakePayment(methods, details) {
-        if (!this.isSupported())
-            return false;
-        const request = new PaymentRequest(methods, details);
-        return request.canMakePayment();
-    }
-    async show(methods, details, options) {
-        if (!this.isSupported()) {
-            throw new Error('Payment Request API not supported');
-        }
-        const request = new PaymentRequest(methods, details, options);
-        const response = await request.show();
-        const result = {
-            methodName: response.methodName,
-            details: response.details,
-            payerName: response.payerName ?? null,
-            payerEmail: response.payerEmail ?? null,
-            payerPhone: response.payerPhone ?? null,
-        };
-        await response.complete('success');
-        return result;
-    }
-    async abort(methods, details) {
-        if (!this.isSupported())
-            return;
-        const request = new PaymentRequest(methods, details);
-        await request.abort();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService, decorators: [{
-            type: Injectable
-        }] });
-
-class CredentialManagementService extends BrowserApiBaseService {
-    getApiName() {
-        return 'credential-management';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'credentials' in navigator;
-    }
-    isPublicKeySupported() {
-        return this.isSupported() && 'PublicKeyCredential' in window;
-    }
-    async get(options) {
-        if (!this.isSupported()) {
-            throw new Error('Credential Management API not supported');
-        }
-        return navigator.credentials.get(options);
-    }
-    async store(credential) {
-        if (!this.isSupported()) {
-            throw new Error('Credential Management API not supported');
-        }
-        await navigator.credentials.store(credential);
-    }
-    async createPasswordCredential(data) {
-        if (!this.isSupported()) {
-            throw new Error('Credential Management API not supported');
-        }
-        return navigator.credentials.create({
-            password: data,
-        });
-    }
-    async createPublicKeyCredential(options) {
-        if (!this.isPublicKeySupported()) {
-            throw new Error('PublicKeyCredential API not supported');
-        }
-        return navigator.credentials.create({
-            publicKey: options,
-        });
-    }
-    async preventSilentAccess() {
-        if (!this.isSupported())
-            return;
-        await navigator.credentials.preventSilentAccess();
-    }
-    async isConditionalMediationAvailable() {
-        if (!this.isPublicKeySupported())
-            return false;
-        if ('isConditionalMediationAvailable' in PublicKeyCredential) {
-            return PublicKeyCredential.isConditionalMediationAvailable();
-        }
-        return false;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService, decorators: [{
-            type: Injectable
-        }] });
-
 // Common types for browser APIs
 
 function injectPageVisibility() {
@@ -3199,42 +3062,6 @@ function injectPerformanceObserver(config) {
     };
 }
 
-function getIdleDetectorClass() {
-    return window.IdleDetector;
-}
-function injectIdleDetector(options = {}) {
-    const destroyRef = inject(DestroyRef);
-    const platformId = inject(PLATFORM_ID);
-    const defaultState = { user: 'active', screen: 'unlocked' };
-    const state = signal(defaultState, ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
-    if (isPlatformBrowser(platformId) && 'IdleDetector' in window) {
-        const abortController = new AbortController();
-        const detector = new (getIdleDetectorClass())();
-        detector.addEventListener('change', () => {
-            state.set({
-                user: detector.userState,
-                screen: detector.screenState,
-            });
-        });
-        detector
-            .start({
-            threshold: options.threshold ?? 60_000,
-            signal: abortController.signal,
-        })
-            .catch(() => {
-            /* permission denied or unsupported — keep defaults */
-        });
-        destroyRef.onDestroy(() => abortController.abort());
-    }
-    return {
-        state: state.asReadonly(),
-        userState: computed(() => state().user),
-        screenState: computed(() => state().screen),
-        isUserIdle: computed(() => state().user === 'idle'),
-        isScreenLocked: computed(() => state().screen === 'locked'),
-    };
-}
-
 function injectGamepad(index, intervalMs = 16) {
     const destroyRef = inject(DestroyRef);
     const platformId = inject(PLATFORM_ID);
@@ -3365,216 +3192,203 @@ const permissionGuard = (permission) => {
     };
 };
 
-const defaultBrowserWebApisConfig = {
-    enableCamera: true,
-    enableGeolocation: true,
-    enableNotifications: true,
-    enableClipboard: true,
-    enableBattery: false,
-    enableMediaDevices: true,
-    enableWebShare: false,
-    enableWebStorage: false,
-    enableWebSocket: false,
-    enableWebWorker: false,
-    enableIntersectionObserver: false,
-    enableResizeObserver: false,
-    enablePageVisibility: false,
-    enableBroadcastChannel: false,
-    enableNetworkInformation: false,
-    enableScreenWakeLock: false,
-    enableScreenOrientation: false,
-    enableFullscreen: false,
-    enableFileSystemAccess: false,
-    enableMediaRecorder: false,
-    enableServerSentEvents: false,
-    enableVibration: false,
-    enableSpeechSynthesis: false,
-    enableMutationObserver: false,
-    enablePerformanceObserver: false,
-    enableIdleDetector: false,
-    enableEyeDropper: false,
-    enableBarcodeDetector: false,
-    enableWebAudio: false,
-    enableGamepad: false,
-    enableWebBluetooth: false,
-    enableWebUsb: false,
-    enableWebNfc: false,
-    enablePaymentRequest: false,
-    enableCredentialManagement: false,
-};
-function provideBrowserWebApis(config = {}) {
-    const mergedConfig = { ...defaultBrowserWebApisConfig, ...config };
-    const providers = [PermissionsService];
-    const conditionalProviders = [
-        [mergedConfig.enableCamera, CameraService],
-        [mergedConfig.enableGeolocation, GeolocationService],
-        [mergedConfig.enableNotifications, NotificationService],
-        [mergedConfig.enableClipboard, ClipboardService],
-        [mergedConfig.enableMediaDevices, MediaDevicesService],
-        [mergedConfig.enableBattery, BatteryService],
-        [mergedConfig.enableWebShare, WebShareService],
-        [mergedConfig.enableWebStorage, WebStorageService],
-        [mergedConfig.enableWebSocket, WebSocketService],
-        [mergedConfig.enableWebWorker, WebWorkerService],
-        [mergedConfig.enableIntersectionObserver, IntersectionObserverService],
-        [mergedConfig.enableResizeObserver, ResizeObserverService],
-        [mergedConfig.enablePageVisibility, PageVisibilityService],
-        [mergedConfig.enableBroadcastChannel, BroadcastChannelService],
-        [mergedConfig.enableNetworkInformation, NetworkInformationService],
-        [mergedConfig.enableScreenWakeLock, ScreenWakeLockService],
-        [mergedConfig.enableScreenOrientation, ScreenOrientationService],
-        [mergedConfig.enableFullscreen, FullscreenService],
-        [mergedConfig.enableFileSystemAccess, FileSystemAccessService],
-        [mergedConfig.enableMediaRecorder, MediaRecorderService],
-        [mergedConfig.enableServerSentEvents, ServerSentEventsService],
-        [mergedConfig.enableVibration, VibrationService],
-        [mergedConfig.enableSpeechSynthesis, SpeechSynthesisService],
-        [mergedConfig.enableMutationObserver, MutationObserverService],
-        [mergedConfig.enablePerformanceObserver, PerformanceObserverService],
-        [mergedConfig.enableIdleDetector, IdleDetectorService],
-        [mergedConfig.enableEyeDropper, EyeDropperService],
-        [mergedConfig.enableBarcodeDetector, BarcodeDetectorService],
-        [mergedConfig.enableWebAudio, WebAudioService],
-        [mergedConfig.enableGamepad, GamepadService],
-        [mergedConfig.enableWebBluetooth, WebBluetoothService],
-        [mergedConfig.enableWebUsb, WebUsbService],
-        [mergedConfig.enableWebNfc, WebNfcService],
-        [mergedConfig.enablePaymentRequest, PaymentRequestService],
-        [mergedConfig.enableCredentialManagement, CredentialManagementService],
-    ];
-    for (const [enabled, provider] of conditionalProviders) {
-        if (enabled) {
-            providers.push(provider);
-        }
-    }
-    return makeEnvironmentProviders(providers);
+function providePermissions() {
+    return makeEnvironmentProviders([PermissionsService]);
 }
-// Feature-specific providers for tree-shaking
+
 function provideCamera() {
-    return makeEnvironmentProviders([PermissionsService, CameraService]);
+    return makeEnvironmentProviders([CameraService]);
 }
+
 function provideGeolocation() {
     return makeEnvironmentProviders([PermissionsService, GeolocationService]);
 }
+
 function provideNotifications() {
     return makeEnvironmentProviders([PermissionsService, NotificationService]);
 }
+
 function provideClipboard() {
-    return makeEnvironmentProviders([PermissionsService, ClipboardService]);
+    return makeEnvironmentProviders([ClipboardService]);
 }
+
 function provideMediaDevices() {
     return makeEnvironmentProviders([PermissionsService, MediaDevicesService]);
 }
+
+function provideScreenWakeLock() {
+    return makeEnvironmentProviders([PermissionsService, ScreenWakeLockService]);
+}
+
+function provideFileSystemAccess() {
+    return makeEnvironmentProviders([PermissionsService, FileSystemAccessService]);
+}
+
+function provideMediaRecorder() {
+    return makeEnvironmentProviders([PermissionsService, MediaRecorderService]);
+}
+
 function provideBattery() {
     return makeEnvironmentProviders([BatteryService]);
 }
+
 function provideWebShare() {
     return makeEnvironmentProviders([WebShareService]);
 }
+
 function provideWebStorage() {
     return makeEnvironmentProviders([WebStorageService]);
 }
+
 function provideWebSocket() {
     return makeEnvironmentProviders([WebSocketService]);
 }
+
 function provideWebWorker() {
     return makeEnvironmentProviders([WebWorkerService]);
 }
-function providePermissions() {
-    return makeEnvironmentProviders([PermissionsService]);
-}
-// Combined providers for common use cases
-function provideMediaApis() {
-    return makeEnvironmentProviders([PermissionsService, CameraService, MediaDevicesService]);
-}
-function provideLocationApis() {
-    return makeEnvironmentProviders([PermissionsService, GeolocationService]);
-}
-function provideStorageApis() {
-    return makeEnvironmentProviders([PermissionsService, ClipboardService, WebStorageService]);
-}
-function provideCommunicationApis() {
-    return makeEnvironmentProviders([
-        PermissionsService,
-        NotificationService,
-        WebShareService,
-        WebSocketService,
-    ]);
-}
+
 function provideIntersectionObserver() {
     return makeEnvironmentProviders([IntersectionObserverService]);
 }
+
 function provideResizeObserver() {
     return makeEnvironmentProviders([ResizeObserverService]);
 }
+
 function providePageVisibility() {
     return makeEnvironmentProviders([PageVisibilityService]);
 }
+
 function provideBroadcastChannel() {
     return makeEnvironmentProviders([BroadcastChannelService]);
 }
+
 function provideNetworkInformation() {
     return makeEnvironmentProviders([NetworkInformationService]);
 }
-function provideScreenWakeLock() {
-    return makeEnvironmentProviders([PermissionsService, ScreenWakeLockService]);
-}
+
 function provideScreenOrientation() {
     return makeEnvironmentProviders([ScreenOrientationService]);
 }
+
 function provideFullscreen() {
     return makeEnvironmentProviders([FullscreenService]);
 }
-function provideFileSystemAccess() {
-    return makeEnvironmentProviders([PermissionsService, FileSystemAccessService]);
-}
-function provideMediaRecorder() {
-    return makeEnvironmentProviders([PermissionsService, MediaRecorderService]);
-}
+
 function provideServerSentEvents() {
     return makeEnvironmentProviders([ServerSentEventsService]);
 }
+
 function provideVibration() {
     return makeEnvironmentProviders([VibrationService]);
 }
+
 function provideSpeechSynthesis() {
     return makeEnvironmentProviders([SpeechSynthesisService]);
 }
+
 function provideMutationObserver() {
     return makeEnvironmentProviders([MutationObserverService]);
 }
+
 function providePerformanceObserver() {
     return makeEnvironmentProviders([PerformanceObserverService]);
 }
-function provideIdleDetector() {
-    return makeEnvironmentProviders([PermissionsService, IdleDetectorService]);
-}
-function provideEyeDropper() {
-    return makeEnvironmentProviders([EyeDropperService]);
-}
-function provideBarcodeDetector() {
-    return makeEnvironmentProviders([BarcodeDetectorService]);
-}
+
 function provideWebAudio() {
     return makeEnvironmentProviders([WebAudioService]);
 }
+
 function provideGamepad() {
     return makeEnvironmentProviders([GamepadService]);
 }
-function provideWebBluetooth() {
-    return makeEnvironmentProviders([WebBluetoothService]);
+
+function provideMediaApis() {
+    return makeEnvironmentProviders([PermissionsService, CameraService, MediaDevicesService]);
 }
-function provideWebUsb() {
-    return makeEnvironmentProviders([WebUsbService]);
+function provideLocationApis() {
+    return makeEnvironmentProviders([PermissionsService, GeolocationService]);
 }
-function provideWebNfc() {
-    return makeEnvironmentProviders([WebNfcService]);
+function provideStorageApis() {
+    return makeEnvironmentProviders([PermissionsService, ClipboardService, WebStorageService]);
 }
-function providePaymentRequest() {
-    return makeEnvironmentProviders([PaymentRequestService]);
+function provideCommunicationApis() {
+    return makeEnvironmentProviders([
+        PermissionsService,
+        NotificationService,
+        WebShareService,
+        WebSocketService,
+    ]);
 }
-function provideCredentialManagement() {
-    return makeEnvironmentProviders([CredentialManagementService]);
+
+const defaultBrowserWebApisConfig = {
+    enableCamera: true,
+    enableGeolocation: true,
+    enableNotifications: true,
+    enableClipboard: true,
+    enableBattery: false,
+    enableMediaDevices: true,
+    enableWebShare: false,
+    enableWebStorage: false,
+    enableWebSocket: false,
+    enableWebWorker: false,
+    enableIntersectionObserver: false,
+    enableResizeObserver: false,
+    enablePageVisibility: false,
+    enableBroadcastChannel: false,
+    enableNetworkInformation: false,
+    enableScreenWakeLock: false,
+    enableScreenOrientation: false,
+    enableFullscreen: false,
+    enableFileSystemAccess: false,
+    enableMediaRecorder: false,
+    enableServerSentEvents: false,
+    enableVibration: false,
+    enableSpeechSynthesis: false,
+    enableMutationObserver: false,
+    enablePerformanceObserver: false,
+    enableWebAudio: false,
+    enableGamepad: false,
+};
+function provideBrowserWebApis(config = {}) {
+    const mergedConfig = { ...defaultBrowserWebApisConfig, ...config };
+    const providers = [PermissionsService];
+    const conditionalProviders = [
+        [mergedConfig.enableCamera, CameraService],
+        [mergedConfig.enableGeolocation, GeolocationService],
+        [mergedConfig.enableNotifications, NotificationService],
+        [mergedConfig.enableClipboard, ClipboardService],
+        [mergedConfig.enableMediaDevices, MediaDevicesService],
+        [mergedConfig.enableBattery, BatteryService],
+        [mergedConfig.enableWebShare, WebShareService],
+        [mergedConfig.enableWebStorage, WebStorageService],
+        [mergedConfig.enableWebSocket, WebSocketService],
+        [mergedConfig.enableWebWorker, WebWorkerService],
+        [mergedConfig.enableIntersectionObserver, IntersectionObserverService],
+        [mergedConfig.enableResizeObserver, ResizeObserverService],
+        [mergedConfig.enablePageVisibility, PageVisibilityService],
+        [mergedConfig.enableBroadcastChannel, BroadcastChannelService],
+        [mergedConfig.enableNetworkInformation, NetworkInformationService],
+        [mergedConfig.enableScreenWakeLock, ScreenWakeLockService],
+        [mergedConfig.enableScreenOrientation, ScreenOrientationService],
+        [mergedConfig.enableFullscreen, FullscreenService],
+        [mergedConfig.enableFileSystemAccess, FileSystemAccessService],
+        [mergedConfig.enableMediaRecorder, MediaRecorderService],
+        [mergedConfig.enableServerSentEvents, ServerSentEventsService],
+        [mergedConfig.enableVibration, VibrationService],
+        [mergedConfig.enableSpeechSynthesis, SpeechSynthesisService],
+        [mergedConfig.enableMutationObserver, MutationObserverService],
+        [mergedConfig.enablePerformanceObserver, PerformanceObserverService],
+        [mergedConfig.enableWebAudio, WebAudioService],
+        [mergedConfig.enableGamepad, GamepadService],
+    ];
+    for (const [enabled, provider] of conditionalProviders) {
+        if (enabled) {
+            providers.push(provider);
+        }
+    }
+    return makeEnvironmentProviders(providers);
 }
 
 // Browser Web APIs Services
@@ -3585,4 +3399,4 @@ const version = '0.1.0';
  * Generated bundle index. Do not edit.
  */
 
-export { BarcodeDetectorService, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, ConnectionRegistryBaseService, CredentialManagementService, EyeDropperService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IdleDetectorService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PaymentRequestService, PerformanceObserverService, PermissionAwareBrowserApiBaseService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, VibrationService, WebAudioService, WebBluetoothService, WebNfcService, WebShareService, WebSocketService, WebStorageService, WebUsbService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectGamepad, injectIdleDetector, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, permissionGuard, provideBarcodeDetector, provideBattery, provideBroadcastChannel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideCredentialManagement, provideEyeDropper, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIdleDetector, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePaymentRequest, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideVibration, provideWebAudio, provideWebBluetooth, provideWebNfc, provideWebShare, provideWebSocket, provideWebStorage, provideWebUsb, provideWebWorker, version };
+export { BROWSER_API_LOGGER, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, ConnectionRegistryBaseService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PerformanceObserverService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, VibrationService, WebAudioService, WebShareService, WebSocketClient, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectGamepad, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, permissionGuard, provideBattery, provideBroadcastChannel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideVibration, provideWebAudio, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version };