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

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

@@ -1,9 +1,9 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, DestroyRef, PLATFORM_ID, Injectable, signal, computed, isSignal, effect, ElementRef, makeEnvironmentProviders } from '@angular/core';
+import { InjectionToken, Injectable, inject, DestroyRef, PLATFORM_ID, 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 { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { filter, map, distinctUntilChanged } from 'rxjs/operators';
 import { Router } from '@angular/router';
 
 const BROWSER_API_LOGGER = new InjectionToken('BROWSER_API_LOGGER', {
@@ -18,14 +18,180 @@ const BROWSER_API_LOGGER = new InjectionToken('BROWSER_API_LOGGER', {
     }),
 });
 
+const BROWSER_CAPABILITIES = [
+    { id: 'permissions', label: 'Permissions API', requiresSecureContext: false },
+    { id: 'geolocation', label: 'Geolocation API', requiresSecureContext: true },
+    { id: 'clipboard', label: 'Clipboard API', requiresSecureContext: true },
+    { id: 'notification', label: 'Notification API', requiresSecureContext: true },
+    { id: 'mediaDevices', label: 'MediaDevices API', requiresSecureContext: true },
+    { id: 'camera', label: 'Camera API', requiresSecureContext: true },
+    { id: 'webWorker', label: 'Web Worker API', requiresSecureContext: false },
+    { id: 'regexSecurity', label: 'Regex Security', requiresSecureContext: false },
+    { id: 'webStorage', label: 'Web Storage', requiresSecureContext: false },
+    { id: 'webShare', label: 'Web Share', requiresSecureContext: true },
+    { id: 'battery', label: 'Battery API', requiresSecureContext: false },
+    { id: 'webSocket', label: 'WebSocket API', requiresSecureContext: false },
+    { id: 'intersectionObserver', label: 'Intersection Observer', requiresSecureContext: false },
+    { id: 'resizeObserver', label: 'Resize Observer', requiresSecureContext: false },
+    { id: 'pageVisibility', label: 'Page Visibility API', requiresSecureContext: false },
+    { id: 'broadcastChannel', label: 'Broadcast Channel API', requiresSecureContext: false },
+    { id: 'networkInformation', label: 'Network Information API', requiresSecureContext: false },
+    { id: 'screenWakeLock', label: 'Screen Wake Lock API', requiresSecureContext: true },
+    { id: 'screenOrientation', label: 'Screen Orientation API', requiresSecureContext: false },
+    { id: 'fullscreen', label: 'Fullscreen API', requiresSecureContext: false },
+    { id: 'fileSystemAccess', label: 'File System Access API', requiresSecureContext: true },
+    { id: 'mediaRecorder', label: 'MediaRecorder API', requiresSecureContext: true },
+    { id: 'serverSentEvents', label: 'Server-Sent Events', requiresSecureContext: false },
+    { id: 'vibration', label: 'Vibration API', requiresSecureContext: false },
+    { id: 'speechSynthesis', label: 'Speech Synthesis API', requiresSecureContext: false },
+    { id: 'mutationObserver', label: 'Mutation Observer', requiresSecureContext: false },
+    { id: 'performanceObserver', label: 'Performance Observer', requiresSecureContext: false },
+    { id: 'idleDetector', label: 'Idle Detection API', requiresSecureContext: true },
+    { id: 'eyeDropper', label: 'EyeDropper API', requiresSecureContext: true },
+    { id: 'barcodeDetector', label: 'Barcode Detection API', requiresSecureContext: true },
+    { id: 'webAudio', label: 'Web Audio API', requiresSecureContext: false },
+    { id: 'gamepad', label: 'Gamepad API', requiresSecureContext: true },
+    { id: 'webBluetooth', label: 'Web Bluetooth API', requiresSecureContext: true },
+    { id: 'webUsb', label: 'WebUSB API', requiresSecureContext: true },
+    { id: 'webNfc', label: 'Web NFC API', requiresSecureContext: true },
+    { id: 'paymentRequest', label: 'Payment Request API', requiresSecureContext: true },
+    { id: 'credentialManagement', label: 'Credential Management API', requiresSecureContext: true },
+];
+class BrowserCapabilityService {
+    getCapabilities() {
+        return BROWSER_CAPABILITIES;
+    }
+    isSecureContext() {
+        return typeof window !== 'undefined' && window.isSecureContext;
+    }
+    isSupported(capability) {
+        switch (capability) {
+            case 'permissions':
+                return typeof navigator !== 'undefined' && 'permissions' in navigator;
+            case 'geolocation':
+                return typeof navigator !== 'undefined' && 'geolocation' in navigator;
+            case 'clipboard':
+                return typeof navigator !== 'undefined' && 'clipboard' in navigator;
+            case 'notification':
+                return typeof window !== 'undefined' && 'Notification' in window;
+            case 'mediaDevices':
+            case 'camera':
+                return typeof navigator !== 'undefined' && 'mediaDevices' in navigator;
+            case 'webWorker':
+            case 'regexSecurity':
+                return typeof Worker !== 'undefined';
+            case 'webStorage':
+                return typeof Storage !== 'undefined';
+            case 'webShare':
+                return typeof navigator !== 'undefined' && 'share' in navigator;
+            case 'battery':
+                return typeof navigator !== 'undefined' && 'getBattery' in navigator;
+            case 'webSocket':
+                return typeof WebSocket !== 'undefined';
+            case 'intersectionObserver':
+                return typeof IntersectionObserver !== 'undefined';
+            case 'resizeObserver':
+                return typeof ResizeObserver !== 'undefined';
+            case 'pageVisibility':
+                return typeof document !== 'undefined' && 'hidden' in document;
+            case 'broadcastChannel':
+                return typeof BroadcastChannel !== 'undefined';
+            case 'networkInformation':
+                return (typeof navigator !== 'undefined' &&
+                    ('connection' in navigator || 'mozConnection' in navigator));
+            case 'screenWakeLock':
+                return typeof navigator !== 'undefined' && 'wakeLock' in navigator;
+            case 'screenOrientation':
+                return typeof screen !== 'undefined' && 'orientation' in screen;
+            case 'fullscreen':
+                return (typeof document !== 'undefined' &&
+                    ('fullscreenEnabled' in document || 'webkitFullscreenEnabled' in document));
+            case 'fileSystemAccess':
+                return typeof window !== 'undefined' && 'showOpenFilePicker' in window;
+            case 'mediaRecorder':
+                return typeof MediaRecorder !== 'undefined';
+            case 'serverSentEvents':
+                return typeof EventSource !== 'undefined';
+            case 'vibration':
+                return typeof navigator !== 'undefined' && 'vibrate' in navigator;
+            case 'speechSynthesis':
+                return typeof window !== 'undefined' && 'speechSynthesis' in window;
+            case 'mutationObserver':
+                return typeof MutationObserver !== 'undefined';
+            case 'performanceObserver':
+                return typeof PerformanceObserver !== 'undefined';
+            case 'idleDetector':
+                return typeof window !== 'undefined' && 'IdleDetector' in window;
+            case 'eyeDropper':
+                return typeof window !== 'undefined' && 'EyeDropper' in window;
+            case 'barcodeDetector':
+                return typeof window !== 'undefined' && 'BarcodeDetector' in window;
+            case 'webAudio':
+                return typeof window !== 'undefined' && 'AudioContext' in window;
+            case 'gamepad':
+                return typeof navigator !== 'undefined' && 'getGamepads' in navigator;
+            case 'webBluetooth':
+                return typeof navigator !== 'undefined' && 'bluetooth' in navigator;
+            case 'webUsb':
+                return typeof navigator !== 'undefined' && 'usb' in navigator;
+            case 'webNfc':
+                return typeof window !== 'undefined' && 'NDEFReader' in window;
+            case 'paymentRequest':
+                return typeof window !== 'undefined' && 'PaymentRequest' in window;
+            case 'credentialManagement':
+                return typeof navigator !== 'undefined' && 'credentials' in navigator;
+            default:
+                return false;
+        }
+    }
+    getAllStatuses() {
+        const secureContext = this.isSecureContext();
+        return this.getCapabilities().map((capability) => ({
+            id: capability.id,
+            label: capability.label,
+            supported: this.isSupported(capability.id),
+            secureContext,
+            requiresSecureContext: capability.requiresSecureContext,
+        }));
+    }
+    async getPermissionState(permission) {
+        if (typeof navigator === 'undefined' || !('permissions' in navigator)) {
+            return 'unknown';
+        }
+        try {
+            const status = await navigator.permissions.query({ name: permission });
+            return status.state;
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 /**
  * Base class for all Browser Web API services.
- * Provides common functionality for:
- * - Platform detection (browser vs server)
- * - Support assertion via Template Method
- * - Error creation with cause chaining
- * - Structured logging via injectable BROWSER_API_LOGGER token
- * - Lifecycle management with destroyRef
+ *
+ * ## Support detection contract
+ *
+ * Services follow ONE pattern (do not invent variants):
+ *
+ * - `isSupported(): boolean` — public, side-effect free, SSR-safe. Default
+ *   implementation delegates to {@link BrowserCapabilityService} when the subclass
+ *   overrides {@link getCapabilityId} (recommended).
+ * - `ensureSupported(): void` — internal Template Method. Throws when called outside
+ *   browser or when the underlying API is missing.
+ *
+ * ## Error surfacing contract
+ *
+ * - **Imperative methods** MUST call `ensureSupported()` and throw synchronously.
+ * - **Stream-returning methods** MUST guard with `isSupported()` and surface
+ *   unsupported state as `Observable.error(...)` (NOT throw inline).
  *
  * Services that also need permission querying should extend
  * `PermissionAwareBrowserApiBaseService` instead.
@@ -34,30 +200,46 @@ class BrowserApiBaseService {
     destroyRef = inject(DestroyRef);
     platformId = inject(PLATFORM_ID);
     logger = inject(BROWSER_API_LOGGER);
+    capabilities = inject(BrowserCapabilityService);
     /**
-     * Check if running in browser environment using Angular's platform detection.
+     * Optional hook for subclasses to delegate feature detection to
+     * {@link BrowserCapabilityService}. Returning a capability id removes the need to
+     * implement `isSupported()` manually and avoids drift between per-service checks
+     * and the centralized capability registry.
      */
+    getCapabilityId() {
+        return null;
+    }
+    /** Public, SSR-safe support check. Override only if you need extra constraints. */
+    isSupported() {
+        if (!this.isBrowserEnvironment())
+            return false;
+        const capabilityId = this.getCapabilityId();
+        if (capabilityId !== null) {
+            return this.capabilities.isSupported(capabilityId);
+        }
+        return true;
+    }
     isBrowserEnvironment() {
         return isPlatformBrowser(this.platformId);
     }
-    /**
-     * Check if running in server environment using Angular's platform detection.
-     */
     isServerEnvironment() {
         return isPlatformServer(this.platformId);
     }
     /**
-     * Template Method: asserts the service can run in the current environment.
-     * Subclasses must call super.ensureSupported() and then add their own API check.
+     * Template Method: asserts the service can run in the current environment. Subclasses
+     * that need extra checks beyond capability detection MUST call `super.ensureSupported()`
+     * first, then add their own check.
      */
     ensureSupported() {
         if (!this.isBrowserEnvironment()) {
             throw new Error(`${this.getApiName()} API not available in server environment`);
         }
+        const capabilityId = this.getCapabilityId();
+        if (capabilityId !== null && !this.capabilities.isSupported(capabilityId)) {
+            throw new Error(`${this.getApiName()} API not supported in this browser`);
+        }
     }
-    /**
-     * Create an error with proper cause chaining.
-     */
     createError(message, cause) {
         const error = new Error(message);
         if (cause !== undefined) {
@@ -65,21 +247,12 @@ class BrowserApiBaseService {
         }
         return error;
     }
-    /**
-     * Log an error through the injected BROWSER_API_LOGGER (default: console).
-     */
     logError(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 through the injected BROWSER_API_LOGGER (default: console).
-     */
     logInfo(message) {
         this.logger.info(`[${this.getApiName()}] ${message}`);
     }
@@ -112,8 +285,8 @@ class PermissionsService extends BrowserApiBaseService {
             throw error;
         }
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'permissions' in navigator;
+    getCapabilityId() {
+        return 'permissions';
     }
     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 });
@@ -127,10 +300,13 @@ class CameraService extends BrowserApiBaseService {
     getApiName() {
         return 'camera';
     }
+    getCapabilityId() {
+        return 'camera';
+    }
     ensureSupported() {
         super.ensureSupported();
         if (!navigator.mediaDevices?.getUserMedia) {
-            throw new Error('Camera API not supported — a secure context (HTTPS) is required');
+            throw new Error('Camera API not supported — getUserMedia missing or HTTPS required');
         }
     }
     async startCamera(constraints) {
@@ -246,11 +422,8 @@ class GeolocationService extends BrowserApiBaseService {
     getApiName() {
         return 'geolocation';
     }
-    ensureSupported() {
-        super.ensureSupported();
-        if (!('geolocation' in navigator)) {
-            throw new Error('Geolocation API not supported — a secure context (HTTPS) is required');
-        }
+    getCapabilityId() {
+        return 'geolocation';
     }
     getCurrentPosition(options) {
         this.ensureSupported();
@@ -292,6 +465,9 @@ class MediaDevicesService extends BrowserApiBaseService {
     getApiName() {
         return 'media-devices';
     }
+    getCapabilityId() {
+        return 'mediaDevices';
+    }
     ensureSupported() {
         super.ensureSupported();
         if (!navigator.mediaDevices) {
@@ -420,11 +596,8 @@ class NotificationService extends BrowserApiBaseService {
     getApiName() {
         return 'notifications';
     }
-    ensureSupported() {
-        super.ensureSupported();
-        if (!('Notification' in window)) {
-            throw new Error('Notifications API not supported in this browser');
-        }
+    getCapabilityId() {
+        return 'notification';
     }
     get permission() {
         if (!this.isBrowserEnvironment() || !('Notification' in window)) {
@@ -460,6 +633,9 @@ class ClipboardService extends BrowserApiBaseService {
     getApiName() {
         return 'clipboard';
     }
+    getCapabilityId() {
+        return 'clipboard';
+    }
     ensureSupported() {
         super.ensureSupported();
         if (!navigator.clipboard) {
@@ -493,173 +669,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-const BROWSER_CAPABILITIES = [
-    { id: 'permissions', label: 'Permissions API', requiresSecureContext: false },
-    { id: 'geolocation', label: 'Geolocation API', requiresSecureContext: true },
-    { id: 'clipboard', label: 'Clipboard API', requiresSecureContext: true },
-    { id: 'notification', label: 'Notification API', requiresSecureContext: true },
-    { id: 'mediaDevices', label: 'MediaDevices API', requiresSecureContext: true },
-    { id: 'camera', label: 'Camera API', requiresSecureContext: true },
-    { id: 'webWorker', label: 'Web Worker API', requiresSecureContext: false },
-    { id: 'regexSecurity', label: 'Regex Security', requiresSecureContext: false },
-    { id: 'webStorage', label: 'Web Storage', requiresSecureContext: false },
-    { id: 'webShare', label: 'Web Share', requiresSecureContext: true },
-    { id: 'battery', label: 'Battery API', requiresSecureContext: false },
-    { id: 'webSocket', label: 'WebSocket API', requiresSecureContext: false },
-    { id: 'intersectionObserver', label: 'Intersection Observer', requiresSecureContext: false },
-    { id: 'resizeObserver', label: 'Resize Observer', requiresSecureContext: false },
-    { id: 'pageVisibility', label: 'Page Visibility API', requiresSecureContext: false },
-    { id: 'broadcastChannel', label: 'Broadcast Channel API', requiresSecureContext: false },
-    { id: 'networkInformation', label: 'Network Information API', requiresSecureContext: false },
-    { id: 'screenWakeLock', label: 'Screen Wake Lock API', requiresSecureContext: true },
-    { id: 'screenOrientation', label: 'Screen Orientation API', requiresSecureContext: false },
-    { id: 'fullscreen', label: 'Fullscreen API', requiresSecureContext: false },
-    { id: 'fileSystemAccess', label: 'File System Access API', requiresSecureContext: true },
-    { id: 'mediaRecorder', label: 'MediaRecorder API', requiresSecureContext: true },
-    { id: 'serverSentEvents', label: 'Server-Sent Events', requiresSecureContext: false },
-    { id: 'vibration', label: 'Vibration API', requiresSecureContext: false },
-    { id: 'speechSynthesis', label: 'Speech Synthesis API', requiresSecureContext: false },
-    { id: 'mutationObserver', label: 'Mutation Observer', requiresSecureContext: false },
-    { id: 'performanceObserver', label: 'Performance Observer', requiresSecureContext: false },
-    { id: 'idleDetector', label: 'Idle Detection API', requiresSecureContext: true },
-    { id: 'eyeDropper', label: 'EyeDropper API', requiresSecureContext: true },
-    { id: 'barcodeDetector', label: 'Barcode Detection API', requiresSecureContext: true },
-    { id: 'webAudio', label: 'Web Audio API', requiresSecureContext: false },
-    { id: 'gamepad', label: 'Gamepad API', requiresSecureContext: true },
-    { id: 'webBluetooth', label: 'Web Bluetooth API', requiresSecureContext: true },
-    { id: 'webUsb', label: 'WebUSB API', requiresSecureContext: true },
-    { id: 'webNfc', label: 'Web NFC API', requiresSecureContext: true },
-    { id: 'paymentRequest', label: 'Payment Request API', requiresSecureContext: true },
-    { id: 'credentialManagement', label: 'Credential Management API', requiresSecureContext: true },
-];
-class BrowserCapabilityService {
-    getCapabilities() {
-        return BROWSER_CAPABILITIES;
-    }
-    isSecureContext() {
-        return typeof window !== 'undefined' && window.isSecureContext;
-    }
-    isSupported(capability) {
-        switch (capability) {
-            case 'permissions':
-                return typeof navigator !== 'undefined' && 'permissions' in navigator;
-            case 'geolocation':
-                return typeof navigator !== 'undefined' && 'geolocation' in navigator;
-            case 'clipboard':
-                return typeof navigator !== 'undefined' && 'clipboard' in navigator;
-            case 'notification':
-                return typeof window !== 'undefined' && 'Notification' in window;
-            case 'mediaDevices':
-            case 'camera':
-                return typeof navigator !== 'undefined' && 'mediaDevices' in navigator;
-            case 'webWorker':
-            case 'regexSecurity':
-                return typeof Worker !== 'undefined';
-            case 'webStorage':
-                return typeof Storage !== 'undefined';
-            case 'webShare':
-                return typeof navigator !== 'undefined' && 'share' in navigator;
-            case 'battery':
-                return typeof navigator !== 'undefined' && 'getBattery' in navigator;
-            case 'webSocket':
-                return typeof WebSocket !== 'undefined';
-            case 'intersectionObserver':
-                return typeof IntersectionObserver !== 'undefined';
-            case 'resizeObserver':
-                return typeof ResizeObserver !== 'undefined';
-            case 'pageVisibility':
-                return typeof document !== 'undefined' && 'hidden' in document;
-            case 'broadcastChannel':
-                return typeof BroadcastChannel !== 'undefined';
-            case 'networkInformation':
-                return (typeof navigator !== 'undefined' &&
-                    ('connection' in navigator || 'mozConnection' in navigator));
-            case 'screenWakeLock':
-                return typeof navigator !== 'undefined' && 'wakeLock' in navigator;
-            case 'screenOrientation':
-                return typeof screen !== 'undefined' && 'orientation' in screen;
-            case 'fullscreen':
-                return (typeof document !== 'undefined' &&
-                    ('fullscreenEnabled' in document || 'webkitFullscreenEnabled' in document));
-            case 'fileSystemAccess':
-                return typeof window !== 'undefined' && 'showOpenFilePicker' in window;
-            case 'mediaRecorder':
-                return typeof MediaRecorder !== 'undefined';
-            case 'serverSentEvents':
-                return typeof EventSource !== 'undefined';
-            case 'vibration':
-                return typeof navigator !== 'undefined' && 'vibrate' in navigator;
-            case 'speechSynthesis':
-                return typeof window !== 'undefined' && 'speechSynthesis' in window;
-            case 'mutationObserver':
-                return typeof MutationObserver !== 'undefined';
-            case 'performanceObserver':
-                return typeof PerformanceObserver !== 'undefined';
-            case 'idleDetector':
-                return typeof window !== 'undefined' && 'IdleDetector' in window;
-            case 'eyeDropper':
-                return typeof window !== 'undefined' && 'EyeDropper' in window;
-            case 'barcodeDetector':
-                return typeof window !== 'undefined' && 'BarcodeDetector' in window;
-            case 'webAudio':
-                return typeof window !== 'undefined' && 'AudioContext' in window;
-            case 'gamepad':
-                return typeof navigator !== 'undefined' && 'getGamepads' in navigator;
-            case 'webBluetooth':
-                return typeof navigator !== 'undefined' && 'bluetooth' in navigator;
-            case 'webUsb':
-                return typeof navigator !== 'undefined' && 'usb' in navigator;
-            case 'webNfc':
-                return typeof window !== 'undefined' && 'NDEFReader' in window;
-            case 'paymentRequest':
-                return typeof window !== 'undefined' && 'PaymentRequest' in window;
-            case 'credentialManagement':
-                return typeof navigator !== 'undefined' && 'credentials' in navigator;
-            default:
-                return false;
-        }
-    }
-    getAllStatuses() {
-        const secureContext = this.isSecureContext();
-        return this.getCapabilities().map((capability) => ({
-            id: capability.id,
-            label: capability.label,
-            supported: this.isSupported(capability.id),
-            secureContext,
-            requiresSecureContext: capability.requiresSecureContext,
-        }));
-    }
-    async getPermissionState(permission) {
-        if (typeof navigator === 'undefined' || !('permissions' in navigator)) {
-            return 'unknown';
-        }
-        try {
-            const status = await navigator.permissions.query({ name: permission });
-            return status.state;
-        }
-        catch {
-            return 'unknown';
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
 class BatteryService extends BrowserApiBaseService {
     batteryManager = null;
     getApiName() {
         return 'battery';
     }
-    ensureSupported() {
-        super.ensureSupported();
-        const nav = navigator;
-        if (!('getBattery' in nav)) {
-            throw new Error('Battery Status API not supported in this browser');
-        }
+    getCapabilityId() {
+        return 'battery';
     }
     async initialize() {
         this.ensureSupported();
@@ -739,11 +755,8 @@ class WebShareService extends BrowserApiBaseService {
     getApiName() {
         return 'web-share';
     }
-    ensureSupported() {
-        super.ensureSupported();
-        if (!('share' in navigator)) {
-            throw new Error('Web Share API not supported in this browser');
-        }
+    getCapabilityId() {
+        return 'webShare';
     }
     async share(data) {
         this.ensureSupported();
@@ -779,255 +792,337 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-class WebStorageService extends BrowserApiBaseService {
-    storageEvents = signal(null, ...(ngDevMode ? [{ debugName: "storageEvents" }] : /* istanbul ignore next */ []));
-    constructor() {
-        super();
-        this.setupEventListeners();
-    }
-    getApiName() {
-        return 'storage';
-    }
-    ensureSupported() {
-        super.ensureSupported();
-        if (typeof Storage === 'undefined') {
-            throw new Error('Storage API not supported in this browser');
-        }
-    }
-    setupEventListeners() {
-        if (this.isBrowserEnvironment()) {
-            fromEvent(window, 'storage')
-                .pipe(takeUntilDestroyed(this.destroyRef))
-                .subscribe((event) => {
-                const storageEvent = event;
-                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,
-                });
-            });
-        }
-    }
-    serializeValue(value, options) {
-        if (options?.serialize) {
-            return options.serialize(value);
-        }
-        return JSON.stringify(value);
+const SECURITY_WARN_KEY = Symbol('storage-security-warned');
+/**
+ * Implementation of `StorageNamespace` shared by `local` and `session` namespaces.
+ * Wraps every native access in try/catch so Safari private mode and sandboxed iframes
+ * (which throw `SecurityError`) degrade gracefully instead of crashing the app.
+ */
+class StorageNamespaceImpl {
+    area;
+    events;
+    logger;
+    supportedCache = null;
+    constructor(area, events, logger) {
+        this.area = area;
+        this.events = events;
+        this.logger = logger;
     }
-    deserializeValue(value, options) {
-        if (value === null)
-            return null;
-        if (options?.deserialize) {
-            return options.deserialize(value);
+    isSupported() {
+        if (this.supportedCache !== null)
+            return this.supportedCache;
+        if (typeof window === 'undefined' || typeof Storage === 'undefined') {
+            this.supportedCache = false;
+            return false;
         }
         try {
-            return JSON.parse(value);
+            const store = this.getStore();
+            const probe = `__bwa_probe_${Date.now()}__`;
+            store.setItem(probe, '1');
+            store.removeItem(probe);
+            this.supportedCache = true;
         }
         catch {
-            return value;
+            this.warnSecurityOnce();
+            this.supportedCache = false;
         }
+        return this.supportedCache;
     }
-    getKey(key, options) {
-        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.ensureSupported();
+    set(key, value, opts = {}) {
+        if (!this.isSupported())
+            return false;
         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');
+            const fullKey = this.getKey(key, opts);
+            const oldRaw = this.getStore().getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, opts) : null;
+            const serialized = this.serializeValue(value, opts);
+            this.getStore().setItem(fullKey, serialized);
+            this.events.emit({ key: fullKey, newValue: value, oldValue, storageArea: this.area });
             return true;
         }
         catch (error) {
-            this.logError('Error setting localStorage:', error);
+            this.logger.error(`[storage:${this.area}] set("${key}") failed`, error);
             return false;
         }
     }
-    getLocalStorage(key, defaultValue = null, options = {}) {
-        this.ensureSupported();
+    get(key, defaultValue = null, opts = {}) {
+        if (!this.isSupported())
+            return defaultValue;
         try {
-            const fullKey = this.getKey(key, options);
-            const value = localStorage.getItem(fullKey);
-            return value !== null ? this.deserializeValue(value, options) : defaultValue;
+            const fullKey = this.getKey(key, opts);
+            const raw = this.getStore().getItem(fullKey);
+            return raw !== null ? this.deserializeValue(raw, opts) : defaultValue;
         }
         catch (error) {
-            this.logError('Error getting localStorage:', error);
+            this.logger.error(`[storage:${this.area}] get("${key}") failed`, error);
             return defaultValue;
         }
     }
-    removeLocalStorage(key, options = {}) {
-        this.ensureSupported();
+    remove(key, opts = {}) {
+        if (!this.isSupported())
+            return false;
         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');
+            const fullKey = this.getKey(key, opts);
+            const oldRaw = this.getStore().getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, opts) : null;
+            this.getStore().removeItem(fullKey);
+            this.events.emit({ key: fullKey, newValue: null, oldValue, storageArea: this.area });
             return true;
         }
         catch (error) {
-            this.logError('Error removing localStorage:', error);
+            this.logger.error(`[storage:${this.area}] remove("${key}") failed`, error);
             return false;
         }
     }
-    clearLocalStorage(options = {}) {
-        this.ensureSupported();
+    clear(opts = {}) {
+        if (!this.isSupported())
+            return false;
         try {
-            const prefix = options?.prefix;
+            const prefix = opts?.prefix;
+            const store = this.getStore();
             if (prefix) {
-                const keysToRemove = [];
-                for (let i = 0; i < localStorage.length; i++) {
-                    const key = localStorage.key(i);
-                    if (key && key.startsWith(`${prefix}:`)) {
-                        keysToRemove.push(key);
-                    }
+                const toRemove = [];
+                for (let i = 0; i < store.length; i++) {
+                    const k = store.key(i);
+                    if (k && k.startsWith(`${prefix}:`))
+                        toRemove.push(k);
+                }
+                for (const k of toRemove) {
+                    const oldRaw = store.getItem(k);
+                    store.removeItem(k);
+                    this.events.emit({
+                        key: k,
+                        newValue: null,
+                        oldValue: oldRaw,
+                        storageArea: this.area,
+                    });
                 }
-                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');
+                store.clear();
+                this.events.emit({ key: null, newValue: null, oldValue: null, storageArea: this.area });
             }
             return true;
         }
         catch (error) {
-            this.logError('Error clearing localStorage:', error);
+            this.logger.error(`[storage:${this.area}] clear() failed`, error);
             return false;
         }
     }
-    // Session Storage Methods
-    setSessionStorage(key, value, options = {}) {
-        this.ensureSupported();
+    size(opts = {}) {
+        if (!this.isSupported())
+            return 0;
         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;
+            const store = this.getStore();
+            const prefix = opts?.prefix;
+            let total = 0;
+            for (let i = 0; i < store.length; i++) {
+                const k = store.key(i);
+                if (k && (!prefix || k.startsWith(`${prefix}:`))) {
+                    total += (store.getItem(k)?.length ?? 0) + k.length;
+                }
+            }
+            return total;
         }
         catch (error) {
-            this.logError('Error setting sessionStorage:', error);
-            return false;
+            this.logger.error(`[storage:${this.area}] size() failed`, error);
+            return 0;
         }
     }
-    getSessionStorage(key, defaultValue = null, options = {}) {
-        this.ensureSupported();
+    watch(key, opts = {}) {
+        const fullKey = this.getKey(key, opts);
+        return this.events.events$.pipe(filter((event) => event.storageArea === this.area && (event.key === null || event.key === fullKey)), map((event) => event.newValue));
+    }
+    native() {
+        if (!this.isSupported()) {
+            throw new Error(`${this.area} not supported in this environment`);
+        }
+        return this.getStore();
+    }
+    getStore() {
+        return this.area === 'localStorage' ? window.localStorage : window.sessionStorage;
+    }
+    getKey(key, opts) {
+        const prefix = opts?.prefix ?? '';
+        return prefix ? `${prefix}:${key}` : key;
+    }
+    serializeValue(value, opts) {
+        if (opts?.serialize)
+            return opts.serialize(value);
+        return JSON.stringify(value);
+    }
+    deserializeValue(value, opts) {
+        if (opts?.deserialize)
+            return opts.deserialize(value);
         try {
-            const fullKey = this.getKey(key, options);
-            const value = sessionStorage.getItem(fullKey);
-            return value !== null ? this.deserializeValue(value, options) : defaultValue;
+            return JSON.parse(value);
         }
-        catch (error) {
-            this.logError('Error getting sessionStorage:', error);
-            return defaultValue;
+        catch {
+            return value;
         }
     }
-    removeSessionStorage(key, options = {}) {
-        this.ensureSupported();
+    warnSecurityOnce() {
+        const holder = globalThis;
+        if (!holder[SECURITY_WARN_KEY])
+            holder[SECURITY_WARN_KEY] = new Set();
+        if (holder[SECURITY_WARN_KEY].has(this.area))
+            return;
+        holder[SECURITY_WARN_KEY].add(this.area);
+        this.logger.warn(`[storage:${this.area}] access denied (SecurityError). Common causes: Safari private mode, ` +
+            'sandboxed iframes, or browser storage disabled. Falling back to default values.');
+    }
+}
+
+let legacyDeprecationLogged$1 = false;
+/**
+ * Web Storage service with two namespaces (`local`, `session`) sharing one method
+ * surface. SecurityError-safe (Safari private mode, sandboxed iframes return defaults
+ * instead of throwing).
+ *
+ * Preferred usage:
+ * ```ts
+ * const storage = inject(WebStorageService);
+ * storage.local.set('user', { id: 1 });
+ * const user = storage.local.get<{ id: number }>('user');
+ * storage.local.watch<{ id: number }>('user').subscribe(console.log);
+ * ```
+ *
+ * Legacy methods (`setLocalStorage`, `getLocalStorage`, etc.) remain as deprecated
+ * wrappers for one minor cycle; removal slated for v22.
+ */
+class WebStorageService extends BrowserApiBaseService {
+    storageLogger = inject(BROWSER_API_LOGGER);
+    storageEvents = signal(null, ...(ngDevMode ? [{ debugName: "storageEvents" }] : /* istanbul ignore next */ []));
+    eventBus = {
+        emit: (event) => this.storageEvents.set(event),
+        events$: toObservable(this.storageEvents).pipe(filter((event) => event !== null), distinctUntilChanged((a, b) => a.key === b.key &&
+            a.newValue === b.newValue &&
+            a.oldValue === b.oldValue &&
+            a.storageArea === b.storageArea)),
+    };
+    /** Local storage namespace. */
+    local = new StorageNamespaceImpl('localStorage', this.eventBus, this.storageLogger);
+    /** Session storage namespace. */
+    session = new StorageNamespaceImpl('sessionStorage', this.eventBus, this.storageLogger);
+    constructor() {
+        super();
+        this.setupCrossTabListener();
+    }
+    getApiName() {
+        return 'storage';
+    }
+    getCapabilityId() {
+        return 'webStorage';
+    }
+    /** Returns true if either local or session storage is usable. */
+    isSupported() {
+        return this.local.isSupported() || this.session.isSupported();
+    }
+    /** Stream of every storage mutation observed in this tab or other tabs. */
+    getStorageEvents() {
+        return this.eventBus.events$;
+    }
+    setupCrossTabListener() {
+        if (!this.isBrowserEnvironment())
+            return;
+        fromEvent(window, 'storage')
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            const area = event.storageArea === window.localStorage ? 'localStorage' : 'sessionStorage';
+            this.storageEvents.set({
+                key: event.key,
+                newValue: event.newValue ? this.safeParse(event.newValue) : null,
+                oldValue: event.oldValue ? this.safeParse(event.oldValue) : null,
+                storageArea: area,
+            });
+        });
+    }
+    safeParse(value) {
         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;
+            return JSON.parse(value);
         }
-        catch (error) {
-            this.logError('Error removing sessionStorage:', error);
-            return false;
+        catch {
+            return value;
         }
     }
+    // ---------- legacy API (deprecated) ----------
+    /** @deprecated Use `storage.local.set(key, value, opts)`. Removed in v22. */
+    setLocalStorage(key, value, options = {}) {
+        this.warnLegacyOnce();
+        return this.local.set(key, value, options);
+    }
+    /** @deprecated Use `storage.local.get(key, defaultValue, opts)`. Removed in v22. */
+    getLocalStorage(key, defaultValue = null, options = {}) {
+        this.warnLegacyOnce();
+        return this.local.get(key, defaultValue, options);
+    }
+    /** @deprecated Use `storage.local.remove(key, opts)`. Removed in v22. */
+    removeLocalStorage(key, options = {}) {
+        this.warnLegacyOnce();
+        return this.local.remove(key, options);
+    }
+    /** @deprecated Use `storage.local.clear(opts)`. Removed in v22. */
+    clearLocalStorage(options = {}) {
+        this.warnLegacyOnce();
+        return this.local.clear(options);
+    }
+    /** @deprecated Use `storage.session.set(key, value, opts)`. Removed in v22. */
+    setSessionStorage(key, value, options = {}) {
+        this.warnLegacyOnce();
+        return this.session.set(key, value, options);
+    }
+    /** @deprecated Use `storage.session.get(key, defaultValue, opts)`. Removed in v22. */
+    getSessionStorage(key, defaultValue = null, options = {}) {
+        this.warnLegacyOnce();
+        return this.session.get(key, defaultValue, options);
+    }
+    /** @deprecated Use `storage.session.remove(key, opts)`. Removed in v22. */
+    removeSessionStorage(key, options = {}) {
+        this.warnLegacyOnce();
+        return this.session.remove(key, options);
+    }
+    /** @deprecated Use `storage.session.clear(opts)`. Removed in v22. */
     clearSessionStorage(options = {}) {
-        this.ensureSupported();
-        try {
-            const prefix = options?.prefix;
-            if (prefix) {
-                const keysToRemove = [];
-                for (let i = 0; i < sessionStorage.length; i++) {
-                    const key = sessionStorage.key(i);
-                    if (key && key.startsWith(`${prefix}:`)) {
-                        keysToRemove.push(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) {
-            this.logError('Error clearing sessionStorage:', error);
-            return false;
-        }
+        this.warnLegacyOnce();
+        return this.session.clear(options);
     }
-    // Utility Methods
+    /** @deprecated Use `storage.local.size(opts)`. Removed in v22. */
     getLocalStorageSize(options = {}) {
-        this.ensureSupported();
-        let totalSize = 0;
-        const prefix = options?.prefix;
-        for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (key && (!prefix || key.startsWith(`${prefix}:`))) {
-                totalSize += (localStorage.getItem(key)?.length || 0) + key.length;
-            }
-        }
-        return totalSize;
+        this.warnLegacyOnce();
+        return this.local.size(options);
     }
+    /** @deprecated Use `storage.session.size(opts)`. Removed in v22. */
     getSessionStorageSize(options = {}) {
-        this.ensureSupported();
-        let totalSize = 0;
-        const prefix = options?.prefix;
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && (!prefix || key.startsWith(`${prefix}:`))) {
-                totalSize += (sessionStorage.getItem(key)?.length || 0) + key.length;
-            }
-        }
-        return totalSize;
-    }
-    getStorageEvents() {
-        return toObservable(this.storageEvents).pipe(filter((event) => event !== null), distinctUntilChanged((prev, curr) => prev.key === curr.key &&
-            prev.newValue === curr.newValue &&
-            prev.oldValue === curr.oldValue));
+        this.warnLegacyOnce();
+        return this.session.size(options);
     }
+    /** @deprecated Use `storage.local.watch<T>(key, opts)`. Removed in v22. */
     watchLocalStorage(key, 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));
+        this.warnLegacyOnce();
+        return this.local.watch(key, options);
     }
+    /** @deprecated Use `storage.session.watch<T>(key, opts)`. Removed in v22. */
     watchSessionStorage(key, 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));
+        this.warnLegacyOnce();
+        return this.session.watch(key, options);
     }
-    // Direct access to native storage APIs
+    /** @deprecated Use `storage.local.native()`. Removed in v22. */
     getNativeLocalStorage() {
-        this.ensureSupported();
-        return localStorage;
+        this.warnLegacyOnce();
+        return this.local.native();
     }
+    /** @deprecated Use `storage.session.native()`. Removed in v22. */
     getNativeSessionStorage() {
-        this.ensureSupported();
-        return sessionStorage;
+        this.warnLegacyOnce();
+        return this.session.native();
+    }
+    warnLegacyOnce() {
+        if (legacyDeprecationLogged$1)
+            return;
+        legacyDeprecationLogged$1 = true;
+        this.storageLogger.warn('[storage] WebStorageService.{set,get,remove,clear,watch}{Local,Session}Storage are ' +
+            'deprecated. Use storage.local and storage.session namespaces. Legacy methods will be ' +
+            'removed in v22.');
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebStorageService });
@@ -1037,7 +1132,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
         }], ctorParameters: () => [] });
 
 const DEFAULT_MAX_RECONNECT_DELAY = 30_000;
-const DEFAULT_REQUEST_TIMEOUT = 30_000;
+const DEFAULT_REQUEST_TIMEOUT$1 = 30_000;
 /**
  * Stateful WebSocket client wrapping a single connection. One instance per logical
  * connection (do NOT share between `connect()` calls).
@@ -1109,7 +1204,7 @@ class WebSocketClient {
      */
     request(type, data, opts) {
         const id = this.generateId();
-        const timeoutMs = opts?.timeout ?? DEFAULT_REQUEST_TIMEOUT;
+        const timeoutMs = opts?.timeout ?? DEFAULT_REQUEST_TIMEOUT$1;
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pendingRequests.delete(id);
@@ -1321,11 +1416,8 @@ class WebSocketService extends BrowserApiBaseService {
     getApiName() {
         return 'websocket';
     }
-    ensureSupported() {
-        super.ensureSupported();
-        if (typeof WebSocket === 'undefined') {
-            throw new Error('WebSocket API not supported in this browser');
-        }
+    getCapabilityId() {
+        return 'webSocket';
     }
     /**
      * Create a new WebSocket client. The client owns one connection and is the recommended
@@ -1483,162 +1575,259 @@ function toObservableLike(client) {
     });
 }
 
+const DEFAULT_REQUEST_TIMEOUT = 30_000;
+/**
+ * Service for creating and managing Web Workers with first-class support for
+ * request/response over `postMessage` (id correlation, timeout, transferables).
+ *
+ * Status is exposed both as a `Signal<WorkerStatus>` (preferred via
+ * {@link getStatusSignal}) and as an `Observable<WorkerStatus>` for backward
+ * compatibility ({@link createWorker}, {@link getStatus}).
+ *
+ * The service registers a single `DestroyRef.onDestroy` in its constructor that
+ * terminates every registered worker; per-worker handlers do not register their
+ * own cleanup callbacks (avoids accumulating callbacks per `setupWorker` call,
+ * a previous leak source).
+ */
 class WebWorkerService extends BrowserApiBaseService {
-    workers = new Map();
-    workerStatuses = new Map();
-    workerMessages = new Map();
-    currentWorkerStatuses = new Map();
+    workerLogger = inject(BROWSER_API_LOGGER);
+    entries = 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');
-        }
+    getCapabilityId() {
+        return 'webWorker';
     }
+    /**
+     * Create a worker. Idempotent: calling twice with the same name returns the
+     * existing entry without recreating the worker.
+     *
+     * Returns an `Observable<WorkerStatus>` for backward compatibility. Prefer
+     * {@link createWorkerSignal} for new code.
+     */
     createWorker(name, scriptUrl) {
+        const status = this.createWorkerSignal(name, scriptUrl);
+        return toObservable(status);
+    }
+    /**
+     * Create a worker (signal-first). Returns the status signal; status is also
+     * accessible later via {@link getStatusSignal}.
+     */
+    createWorkerSignal(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,
-                    running: true,
-                    messageCount: 0,
-                };
-                this.currentWorkerStatuses.set(name, status);
-                this.updateWorkerStatus(name, status);
-                observer.next(status);
-            }
-            catch (error) {
-                this.logError(`Failed to create worker ${name}:`, error);
-                const status = {
-                    initialized: false,
-                    running: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                    messageCount: 0,
-                };
-                this.currentWorkerStatuses.set(name, status);
-                this.updateWorkerStatus(name, status);
-                observer.next(status);
-            }
-            return () => {
-                // No-op: workers are managed explicitly via terminateWorker/terminateAllWorkers
-            };
-        });
+        const existing = this.entries.get(name);
+        if (existing && existing.worker)
+            return existing.status.asReadonly();
+        const entry = this.ensureEntry(name);
+        try {
+            const worker = new Worker(scriptUrl);
+            entry.worker = worker;
+            this.attachHandlers(name, entry);
+            entry.status.set({ initialized: true, running: true, messageCount: 0 });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            entry.status.set({
+                initialized: false,
+                running: false,
+                error: message,
+                messageCount: 0,
+            });
+            this.workerLogger.error(`[webworker] Failed to create worker "${name}"`, error);
+        }
+        return entry.status.asReadonly();
     }
     terminateWorker(name) {
-        const worker = this.workers.get(name);
-        if (worker) {
-            worker.terminate();
-            this.workers.delete(name);
-            this.workerStatuses.delete(name);
-            this.workerMessages.delete(name);
-            this.currentWorkerStatuses.delete(name);
-        }
+        const entry = this.entries.get(name);
+        if (!entry)
+            return;
+        this.rejectPending(entry, new Error(`Worker "${name}" terminated`));
+        if (entry.worker)
+            entry.worker.terminate();
+        entry.messages$.complete();
+        this.entries.delete(name);
     }
     terminateAllWorkers() {
-        this.workers.forEach((_, name) => {
+        for (const name of [...this.entries.keys()]) {
             this.terminateWorker(name);
-        });
+        }
     }
+    /** Send a fire-and-forget message. Use {@link request} when you need a reply. */
     postMessage(workerName, task) {
-        const worker = this.workers.get(workerName);
-        if (!worker) {
-            this.logError(`Worker ${workerName} not found`);
+        const entry = this.entries.get(workerName);
+        if (!entry || !entry.worker) {
+            this.workerLogger.error(`[webworker] postMessage: worker "${workerName}" not found`);
             return;
         }
+        const message = {
+            id: task.id ?? this.generateId(),
+            type: task.type,
+            data: task.data,
+            timestamp: Date.now(),
+        };
         try {
-            const message = { ...task, timestamp: Date.now() };
             if (task.transferable) {
-                worker.postMessage(message, task.transferable);
+                entry.worker.postMessage(message, task.transferable);
             }
             else {
-                worker.postMessage(message);
-            }
-            const currentStatus = this.currentWorkerStatuses.get(workerName);
-            if (currentStatus) {
-                currentStatus.messageCount++;
-                this.updateWorkerStatus(workerName, currentStatus);
+                entry.worker.postMessage(message);
             }
+            this.bumpMessageCount(entry);
         }
         catch (error) {
-            this.logError(`Failed to post message to worker ${workerName}:`, error);
+            this.workerLogger.error(`[webworker] postMessage failed for "${workerName}"`, error);
         }
     }
-    getMessages(workerName) {
-        if (!this.workerMessages.has(workerName)) {
-            this.workerMessages.set(workerName, new Subject());
+    /**
+     * Send a message and await a correlated response. The worker MUST send back a
+     * message containing `correlationId` matching the request id.
+     *
+     * ```ts
+     * const result = await ws.request<{ ok: boolean }>('worker', 'compute', { n: 1 });
+     * ```
+     */
+    request(workerName, type, data, opts) {
+        const entry = this.entries.get(workerName);
+        if (!entry || !entry.worker) {
+            return Promise.reject(new Error(`Worker "${workerName}" not found`));
         }
-        return this.workerMessages.get(workerName).asObservable();
+        const id = this.generateId();
+        const timeoutMs = opts?.timeout ?? DEFAULT_REQUEST_TIMEOUT;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                entry.pending.delete(id);
+                reject(new Error(`WebWorker "${workerName}" request timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+            entry.pending.set(id, {
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            const message = {
+                id,
+                type,
+                data,
+                timestamp: Date.now(),
+                correlationId: id,
+            };
+            try {
+                if (opts?.transferable) {
+                    entry.worker.postMessage(message, opts.transferable);
+                }
+                else {
+                    entry.worker.postMessage(message);
+                }
+                this.bumpMessageCount(entry);
+            }
+            catch (error) {
+                clearTimeout(timer);
+                entry.pending.delete(id);
+                reject(error instanceof Error ? error : new Error('postMessage failed'));
+            }
+        });
+    }
+    getMessages(workerName) {
+        const entry = this.ensureEntry(workerName);
+        return entry.messages$.asObservable();
+    }
+    getMessagesByType(workerName, type) {
+        return this.getMessages(workerName).pipe(filter((m) => m.type === type));
     }
+    /** @deprecated Use {@link getStatusSignal}. Kept as Observable for backward compat. */
     getStatus(workerName) {
-        if (!this.workerStatuses.has(workerName)) {
-            this.workerStatuses.set(workerName, new Subject());
-        }
-        return this.workerStatuses.get(workerName).asObservable();
+        return toObservable(this.getStatusSignal(workerName));
+    }
+    getStatusSignal(workerName) {
+        return this.ensureEntry(workerName).status.asReadonly();
     }
     getCurrentStatus(workerName) {
-        return this.currentWorkerStatuses.get(workerName);
+        return this.entries.get(workerName)?.status();
     }
     getAllStatuses() {
-        return new Map(this.currentWorkerStatuses);
+        const result = new Map();
+        for (const [name, entry] of this.entries)
+            result.set(name, entry.status());
+        return result;
     }
     isWorkerRunning(workerName) {
-        const status = this.currentWorkerStatuses.get(workerName);
-        return status?.running ?? false;
+        return this.entries.get(workerName)?.status().running ?? false;
+    }
+    getNativeWorker(name) {
+        return this.entries.get(name)?.worker ?? undefined;
+    }
+    getAllWorkers() {
+        const result = new Map();
+        for (const [name, entry] of this.entries) {
+            if (entry.worker)
+                result.set(name, entry.worker);
+        }
+        return result;
     }
-    setupWorker(name, worker) {
-        worker.onmessage = (event) => {
+    // ---------- internals ----------
+    attachHandlers(name, entry) {
+        if (!entry.worker)
+            return;
+        entry.worker.onmessage = (event) => {
+            const data = event.data ?? {};
+            const correlationId = data.correlationId ?? data.id;
+            if (correlationId && entry.pending.has(correlationId)) {
+                const p = entry.pending.get(correlationId);
+                clearTimeout(p.timer);
+                entry.pending.delete(correlationId);
+                p.resolve(data.data);
+                return;
+            }
             const message = {
-                id: event.data.id || `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-                type: event.data.type || 'message',
-                data: event.data.data,
-                timestamp: event.data.timestamp || Date.now(),
+                id: data.id ?? this.generateId(),
+                type: data.type ?? 'message',
+                data: data.data,
+                timestamp: data.timestamp ?? Date.now(),
+                correlationId: data.correlationId,
             };
-            if (!this.workerMessages.has(name)) {
-                this.workerMessages.set(name, new Subject());
-            }
-            this.workerMessages.get(name).next(message);
+            entry.messages$.next(message);
         };
-        worker.onerror = (error) => {
-            this.logError(`Worker ${name} error:`, error);
-            const status = {
-                initialized: true,
+        entry.worker.onerror = (error) => {
+            this.workerLogger.error(`[webworker] Worker "${name}" error`, error);
+            entry.status.update((s) => ({
+                ...s,
                 running: false,
                 error: error instanceof Error ? error.message : 'Worker error',
-                messageCount: this.currentWorkerStatuses.get(name)?.messageCount ?? 0,
-            };
-            this.currentWorkerStatuses.set(name, status);
-            this.updateWorkerStatus(name, status);
+            }));
         };
-        // Auto-cleanup when service is destroyed
-        this.destroyRef.onDestroy(() => {
-            this.terminateWorker(name);
-        });
     }
-    updateWorkerStatus(name, status) {
-        if (!this.workerStatuses.has(name)) {
-            this.workerStatuses.set(name, new Subject());
+    rejectPending(entry, reason) {
+        for (const p of entry.pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(reason);
         }
-        this.workerStatuses.get(name).next(status);
+        entry.pending.clear();
     }
-    // Direct access to native Worker API
-    getNativeWorker(name) {
-        return this.workers.get(name);
+    bumpMessageCount(entry) {
+        entry.status.update((s) => ({ ...s, messageCount: s.messageCount + 1 }));
     }
-    getAllWorkers() {
-        return new Map(this.workers);
+    ensureEntry(workerName) {
+        let entry = this.entries.get(workerName);
+        if (!entry) {
+            entry = {
+                worker: null,
+                status: signal({
+                    initialized: false,
+                    running: false,
+                    messageCount: 0,
+                }),
+                messages$: new Subject(),
+                pending: new Map(),
+            };
+            this.entries.set(workerName, entry);
+        }
+        return entry;
+    }
+    generateId() {
+        if (typeof globalThis.crypto?.randomUUID === 'function') {
+            return globalThis.crypto.randomUUID();
+        }
+        return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebWorkerService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebWorkerService });
@@ -1678,8 +1867,8 @@ class IntersectionObserverService extends BrowserApiBaseService {
     getApiName() {
         return 'intersection-observer';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'IntersectionObserver' in window;
+    getCapabilityId() {
+        return 'intersectionObserver';
     }
     observe(element, options = {}) {
         if (!this.isSupported()) {
@@ -1738,8 +1927,8 @@ class ResizeObserverService extends BrowserApiBaseService {
     getApiName() {
         return 'resize-observer';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'ResizeObserver' in window;
+    getCapabilityId() {
+        return 'resizeObserver';
     }
     observe(element, options = {}) {
         if (!this.isSupported()) {
@@ -1779,8 +1968,8 @@ class PageVisibilityService extends BrowserApiBaseService {
     getApiName() {
         return 'page-visibility';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'hidden' in document;
+    getCapabilityId() {
+        return 'pageVisibility';
     }
     get isHidden() {
         if (!this.isSupported())
@@ -1856,13 +2045,11 @@ class BroadcastChannelService extends ConnectionRegistryBaseService {
     closeNativeConnection(channel) {
         channel.close();
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'BroadcastChannel' in window;
+    getCapabilityId() {
+        return 'broadcastChannel';
     }
     ensureBroadcastChannelSupported() {
-        if (!this.isSupported()) {
-            throw new Error('BroadcastChannel API not supported in this environment');
-        }
+        this.ensureSupported();
     }
     open(name) {
         this.ensureBroadcastChannelSupported();
@@ -1959,8 +2146,8 @@ class NetworkInformationService extends BrowserApiBaseService {
     getApiName() {
         return 'network-information';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && isNetworkInformationSupported();
+    getCapabilityId() {
+        return 'networkInformation';
     }
     getSnapshot() {
         return this.isBrowserEnvironment() ? getNetworkSnapshot() : { online: true };
@@ -1983,8 +2170,8 @@ class ScreenWakeLockService extends BrowserApiBaseService {
     getApiName() {
         return 'screen-wake-lock';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'wakeLock' in navigator;
+    getCapabilityId() {
+        return 'screenWakeLock';
     }
     get isActive() {
         return this.sentinel !== null && !this.sentinel.released;
@@ -2078,8 +2265,8 @@ class ScreenOrientationService extends BrowserApiBaseService {
     getApiName() {
         return 'screen-orientation';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'screen' in window && 'orientation' in screen;
+    getCapabilityId() {
+        return 'screenOrientation';
     }
     getSnapshot() {
         return this.isBrowserEnvironment()
@@ -2123,8 +2310,12 @@ class FullscreenService extends BrowserApiBaseService {
     getApiName() {
         return 'fullscreen';
     }
+    getCapabilityId() {
+        return 'fullscreen';
+    }
+    /** Override to also check the *enabled* flag (browser may have disabled fullscreen). */
     isSupported() {
-        if (!this.isBrowserEnvironment())
+        if (!super.isSupported())
             return false;
         return !!(document.fullscreenEnabled ??
             document.webkitFullscreenEnabled);
@@ -2215,17 +2406,18 @@ class FileSystemAccessService extends BrowserApiBaseService {
     getApiName() {
         return 'file-system-access';
     }
+    getCapabilityId() {
+        return 'fileSystemAccess';
+    }
+    /** Override to also assert secure context (required by the spec). */
     isSupported() {
-        return this.isBrowserEnvironment() && 'showOpenFilePicker' in window && window.isSecureContext;
+        return super.isSupported() && typeof window !== 'undefined' && window.isSecureContext;
     }
     get win() {
         return window;
     }
     ensureSupported() {
         super.ensureSupported();
-        if (!('showOpenFilePicker' in window)) {
-            throw new Error('File System Access API not supported in this browser');
-        }
         if (!window.isSecureContext) {
             throw new Error('File System Access API requires a secure context (HTTPS)');
         }
@@ -2301,8 +2493,8 @@ class MediaRecorderService extends BrowserApiBaseService {
     getApiName() {
         return 'media-recorder';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'MediaRecorder' in window;
+    getCapabilityId() {
+        return 'mediaRecorder';
     }
     get state() {
         return this.recorder?.state ?? 'inactive';
@@ -2392,13 +2584,11 @@ class ServerSentEventsService extends ConnectionRegistryBaseService {
     closeNativeConnection(source) {
         source.close();
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'EventSource' in window;
+    getCapabilityId() {
+        return 'serverSentEvents';
     }
     ensureSSESupported() {
-        if (!this.isSupported()) {
-            throw new Error('Server-Sent Events (EventSource) not supported in this environment');
-        }
+        this.ensureSupported();
     }
     connect(url, config = {}) {
         this.ensureSSESupported();
@@ -2478,8 +2668,8 @@ class VibrationService extends BrowserApiBaseService {
         notification: [200],
         doubleTap: [50, 100, 50],
     };
-    isSupported() {
-        return this.isBrowserEnvironment() && 'vibrate' in navigator;
+    getCapabilityId() {
+        return 'vibration';
     }
     vibrate(pattern = 200) {
         if (!this.isSupported())
@@ -2512,13 +2702,11 @@ class SpeechSynthesisService extends BrowserApiBaseService {
     getApiName() {
         return 'speech-synthesis';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'speechSynthesis' in window;
+    getCapabilityId() {
+        return 'speechSynthesis';
     }
     ensureSpeechSynthesisSupported() {
-        if (!this.isSupported()) {
-            throw new Error('Speech Synthesis API not supported in this browser');
-        }
+        this.ensureSupported();
     }
     get state() {
         if (!this.isSupported())
@@ -2628,8 +2816,8 @@ class MutationObserverService extends BrowserApiBaseService {
     getApiName() {
         return 'mutation-observer';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && isMutationObserverSupported();
+    getCapabilityId() {
+        return 'mutationObserver';
     }
     observe(target, options) {
         if (!this.isSupported()) {
@@ -2666,8 +2854,8 @@ class PerformanceObserverService extends BrowserApiBaseService {
     getApiName() {
         return 'performance-observer';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && isPerformanceObserverSupported();
+    getCapabilityId() {
+        return 'performanceObserver';
     }
     observe(config) {
         if (!this.isSupported()) {
@@ -2695,8 +2883,8 @@ class WebAudioService extends BrowserApiBaseService {
         return 'web-audio';
     }
     context = null;
-    isSupported() {
-        return this.isBrowserEnvironment() && 'AudioContext' in window;
+    getCapabilityId() {
+        return 'webAudio';
     }
     getContext() {
         if (!this.isSupported()) {
@@ -2857,8 +3045,8 @@ class GamepadService extends BrowserApiBaseService {
     getApiName() {
         return 'gamepad';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && isGamepadSupported();
+    getCapabilityId() {
+        return 'gamepad';
     }
     getSnapshot(index) {
         if (!this.isSupported())
@@ -3078,6 +3266,257 @@ function injectGamepad(index, intervalMs = 16) {
     };
 }
 
+function injectClipboard() {
+    const destroyRef = inject(DestroyRef);
+    const platformId = inject(PLATFORM_ID);
+    const isBrowser = isPlatformBrowser(platformId);
+    const supported = signal(isBrowser && typeof navigator !== 'undefined' && !!navigator.clipboard, ...(ngDevMode ? [{ debugName: "supported" }] : /* istanbul ignore next */ []));
+    const text = signal(null, ...(ngDevMode ? [{ debugName: "text" }] : /* istanbul ignore next */ []));
+    const error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+    const busy = signal(false, ...(ngDevMode ? [{ debugName: "busy" }] : /* istanbul ignore next */ []));
+    let disposed = false;
+    destroyRef.onDestroy(() => {
+        disposed = true;
+    });
+    const writeText = async (value) => {
+        if (!supported() || disposed) {
+            error.set('Clipboard API not supported');
+            return false;
+        }
+        busy.set(true);
+        try {
+            await navigator.clipboard.writeText(value);
+            if (!disposed) {
+                text.set(value);
+                error.set(null);
+            }
+            return true;
+        }
+        catch (err) {
+            if (!disposed)
+                error.set(err instanceof Error ? err.message : 'writeText failed');
+            return false;
+        }
+        finally {
+            if (!disposed)
+                busy.set(false);
+        }
+    };
+    const readText = async () => {
+        if (!supported() || disposed) {
+            error.set('Clipboard API not supported');
+            return null;
+        }
+        busy.set(true);
+        try {
+            const value = await navigator.clipboard.readText();
+            if (!disposed) {
+                text.set(value);
+                error.set(null);
+            }
+            return value;
+        }
+        catch (err) {
+            if (!disposed)
+                error.set(err instanceof Error ? err.message : 'readText failed');
+            return null;
+        }
+        finally {
+            if (!disposed)
+                busy.set(false);
+        }
+    };
+    return {
+        text: text.asReadonly(),
+        error: error.asReadonly(),
+        busy: busy.asReadonly(),
+        isSupported: supported.asReadonly(),
+        writeText,
+        readText,
+    };
+}
+
+function injectGeolocation(opts = {}) {
+    const destroyRef = inject(DestroyRef);
+    const platformId = inject(PLATFORM_ID);
+    const isBrowser = isPlatformBrowser(platformId);
+    const supported = signal(isBrowser && typeof navigator !== 'undefined' && 'geolocation' in navigator, ...(ngDevMode ? [{ debugName: "supported" }] : /* istanbul ignore next */ []));
+    const position = signal(null, ...(ngDevMode ? [{ debugName: "position" }] : /* istanbul ignore next */ []));
+    const error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+    const watching = signal(false, ...(ngDevMode ? [{ debugName: "watching" }] : /* istanbul ignore next */ []));
+    let watchId = null;
+    const watch = (positionOpts) => {
+        if (!supported() || watchId !== null)
+            return;
+        watching.set(true);
+        watchId = navigator.geolocation.watchPosition((pos) => {
+            position.set(pos);
+            error.set(null);
+        }, (err) => error.set(err), positionOpts);
+    };
+    const stop = () => {
+        if (watchId !== null) {
+            navigator.geolocation.clearWatch(watchId);
+            watchId = null;
+        }
+        watching.set(false);
+    };
+    const getCurrent = (positionOpts) => {
+        if (!supported()) {
+            return Promise.reject(new Error('Geolocation API not supported'));
+        }
+        return new Promise((resolve, reject) => {
+            navigator.geolocation.getCurrentPosition((pos) => {
+                position.set(pos);
+                error.set(null);
+                resolve(pos);
+            }, (err) => {
+                error.set(err);
+                reject(err);
+            }, positionOpts);
+        });
+    };
+    destroyRef.onDestroy(() => stop());
+    if (opts.watch)
+        watch(opts);
+    return {
+        position: position.asReadonly(),
+        error: error.asReadonly(),
+        watching: watching.asReadonly(),
+        isSupported: supported.asReadonly(),
+        watch,
+        stop,
+        getCurrent,
+    };
+}
+
+function injectBattery() {
+    const destroyRef = inject(DestroyRef);
+    const platformId = inject(PLATFORM_ID);
+    const isBrowser = isPlatformBrowser(platformId);
+    const supported = signal(isBrowser && typeof navigator !== 'undefined' && 'getBattery' in navigator, ...(ngDevMode ? [{ debugName: "supported" }] : /* istanbul ignore next */ []));
+    const info = signal(null, ...(ngDevMode ? [{ debugName: "info" }] : /* istanbul ignore next */ []));
+    const error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+    let manager = null;
+    let disposed = false;
+    const snapshot = () => manager
+        ? {
+            charging: manager.charging,
+            level: manager.level,
+            chargingTime: manager.chargingTime,
+            dischargingTime: manager.dischargingTime,
+        }
+        : null;
+    const update = () => {
+        if (!disposed)
+            info.set(snapshot());
+    };
+    const events = [
+        'chargingchange',
+        'levelchange',
+        'chargingtimechange',
+        'dischargingtimechange',
+    ];
+    const refresh = async () => {
+        if (!supported() || disposed)
+            return;
+        try {
+            if (!manager) {
+                const nav = navigator;
+                manager = await nav.getBattery();
+                for (const ev of events) {
+                    manager.addEventListener(ev, update);
+                }
+            }
+            update();
+        }
+        catch (err) {
+            if (!disposed)
+                error.set(err instanceof Error ? err.message : 'getBattery failed');
+        }
+    };
+    destroyRef.onDestroy(() => {
+        disposed = true;
+        if (manager) {
+            for (const ev of events) {
+                manager.removeEventListener(ev, update);
+            }
+            manager = null;
+        }
+    });
+    if (supported())
+        void refresh();
+    return {
+        info: info.asReadonly(),
+        error: error.asReadonly(),
+        isSupported: supported.asReadonly(),
+        refresh,
+    };
+}
+
+function injectWakeLock() {
+    const destroyRef = inject(DestroyRef);
+    const platformId = inject(PLATFORM_ID);
+    const isBrowser = isPlatformBrowser(platformId);
+    const supported = signal(isBrowser && typeof navigator !== 'undefined' && 'wakeLock' in navigator, ...(ngDevMode ? [{ debugName: "supported" }] : /* istanbul ignore next */ []));
+    const active = signal(false, ...(ngDevMode ? [{ debugName: "active" }] : /* istanbul ignore next */ []));
+    const error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+    let sentinel = null;
+    let disposed = false;
+    const onRelease = () => {
+        if (!disposed)
+            active.set(false);
+        sentinel = null;
+    };
+    const request = async () => {
+        if (!supported() || disposed) {
+            error.set('Screen Wake Lock API not supported');
+            return false;
+        }
+        if (sentinel && !sentinel.released)
+            return true;
+        try {
+            const nav = navigator;
+            sentinel = await nav.wakeLock.request('screen');
+            sentinel.addEventListener('release', onRelease);
+            if (!disposed) {
+                active.set(true);
+                error.set(null);
+            }
+            return true;
+        }
+        catch (err) {
+            if (!disposed)
+                error.set(err instanceof Error ? err.message : 'wakeLock.request failed');
+            return false;
+        }
+    };
+    const release = async () => {
+        if (!sentinel || sentinel.released)
+            return;
+        try {
+            await sentinel.release();
+        }
+        finally {
+            onRelease();
+        }
+    };
+    destroyRef.onDestroy(() => {
+        disposed = true;
+        if (sentinel && !sentinel.released) {
+            void sentinel.release();
+        }
+        sentinel = null;
+    });
+    return {
+        active: active.asReadonly(),
+        error: error.asReadonly(),
+        isSupported: supported.asReadonly(),
+        request,
+        release,
+    };
+}
+
 class BrowserSupportUtil {
     static isSupported(feature) {
         if (typeof window === 'undefined' || typeof navigator === 'undefined') {
@@ -3399,4 +3838,4 @@ const version = '0.1.0';
  * Generated bundle index. Do not edit.
  */
 
-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 };
+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, injectBattery, injectClipboard, injectGamepad, injectGeolocation, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, injectWakeLock, 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 };