@angular-helpers/browser-web-apis 21.7.0 → 21.10.0

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

@@ -1,5 +1,5 @@
 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 { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
@@ -18,14 +18,191 @@ 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 },
+    { id: 'webLocks', label: 'Web Locks API', requiresSecureContext: true },
+    { id: 'storageManager', label: 'Storage Manager API', requiresSecureContext: true },
+    { id: 'compressionStreams', label: 'Compression Streams API', requiresSecureContext: false },
+];
+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;
+            case 'webLocks':
+                return typeof navigator !== 'undefined' && 'locks' in navigator;
+            case 'storageManager':
+                return (typeof navigator !== 'undefined' &&
+                    'storage' in navigator &&
+                    typeof navigator.storage.estimate === 'function');
+            case 'compressionStreams':
+                return (typeof CompressionStream !== 'undefined' && typeof DecompressionStream !== 'undefined');
+            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 +211,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 +258,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 +296,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 +311,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 +433,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 +476,9 @@ class MediaDevicesService extends BrowserApiBaseService {
     getApiName() {
         return 'media-devices';
     }
+    getCapabilityId() {
+        return 'mediaDevices';
+    }
     ensureSupported() {
         super.ensureSupported();
         if (!navigator.mediaDevices) {
@@ -420,11 +607,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 +644,9 @@ class ClipboardService extends BrowserApiBaseService {
     getApiName() {
         return 'clipboard';
     }
+    getCapabilityId() {
+        return 'clipboard';
+    }
     ensureSupported() {
         super.ensureSupported();
         if (!navigator.clipboard) {
@@ -493,173 +680,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 +766,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();
@@ -998,11 +1022,8 @@ class WebStorageService extends BrowserApiBaseService {
     getApiName() {
         return 'storage';
     }
-    ensureSupported() {
-        super.ensureSupported();
-        if (typeof Storage === 'undefined') {
-            throw new Error('Storage API not supported in this browser');
-        }
+    getCapabilityId() {
+        return 'webStorage';
     }
     /** Returns true if either local or session storage is usable. */
     isSupported() {
@@ -1122,7 +1143,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).
@@ -1194,7 +1215,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);
@@ -1406,11 +1427,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
@@ -1568,162 +1586,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;
     }
-    setupWorker(name, worker) {
-        worker.onmessage = (event) => {
+    getAllWorkers() {
+        const result = new Map();
+        for (const [name, entry] of this.entries) {
+            if (entry.worker)
+                result.set(name, entry.worker);
+        }
+        return result;
+    }
+    // ---------- 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 });
@@ -1763,8 +1878,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()) {
@@ -1823,8 +1938,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()) {
@@ -1864,8 +1979,8 @@ class PageVisibilityService extends BrowserApiBaseService {
     getApiName() {
         return 'page-visibility';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'hidden' in document;
+    getCapabilityId() {
+        return 'pageVisibility';
     }
     get isHidden() {
         if (!this.isSupported())
@@ -1941,13 +2056,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();
@@ -2044,8 +2157,8 @@ class NetworkInformationService extends BrowserApiBaseService {
     getApiName() {
         return 'network-information';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && isNetworkInformationSupported();
+    getCapabilityId() {
+        return 'networkInformation';
     }
     getSnapshot() {
         return this.isBrowserEnvironment() ? getNetworkSnapshot() : { online: true };
@@ -2068,8 +2181,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;
@@ -2163,8 +2276,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()
@@ -2208,8 +2321,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);
@@ -2300,17 +2417,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)');
         }
@@ -2386,8 +2504,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';
@@ -2477,13 +2595,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();
@@ -2563,8 +2679,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())
@@ -2597,13 +2713,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())
@@ -2713,8 +2827,8 @@ class MutationObserverService extends BrowserApiBaseService {
     getApiName() {
         return 'mutation-observer';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && isMutationObserverSupported();
+    getCapabilityId() {
+        return 'mutationObserver';
     }
     observe(target, options) {
         if (!this.isSupported()) {
@@ -2751,8 +2865,8 @@ class PerformanceObserverService extends BrowserApiBaseService {
     getApiName() {
         return 'performance-observer';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && isPerformanceObserverSupported();
+    getCapabilityId() {
+        return 'performanceObserver';
     }
     observe(config) {
         if (!this.isSupported()) {
@@ -2780,8 +2894,8 @@ class WebAudioService extends BrowserApiBaseService {
         return 'web-audio';
     }
     context = null;
-    isSupported() {
-        return this.isBrowserEnvironment() && 'AudioContext' in window;
+    getCapabilityId() {
+        return 'webAudio';
     }
     getContext() {
         if (!this.isSupported()) {
@@ -2942,8 +3056,8 @@ class GamepadService extends BrowserApiBaseService {
     getApiName() {
         return 'gamepad';
     }
-    isSupported() {
-        return this.isBrowserEnvironment() && isGamepadSupported();
+    getCapabilityId() {
+        return 'gamepad';
     }
     getSnapshot(index) {
         if (!this.isSupported())
@@ -2984,6 +3098,193 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
+/**
+ * Service wrapping `navigator.locks` (Web Locks API). Coordinates exclusive or
+ * shared access to a named resource across tabs and workers.
+ *
+ * ```ts
+ * const locks = inject(WebLocksService);
+ * await locks.acquire('user-cache', async () => {
+ *   // critical section — no other tab is in this block at the same time
+ * });
+ * ```
+ */
+class WebLocksService extends BrowserApiBaseService {
+    getApiName() {
+        return 'web-locks';
+    }
+    isSupported() {
+        if (!this.isBrowserEnvironment())
+            return false;
+        return !!navigator.locks;
+    }
+    /**
+     * Acquire a lock and run the callback while holding it. The lock is released
+     * automatically when the callback resolves or rejects.
+     */
+    acquire(name, callback, options = {}) {
+        this.ensureSupported();
+        const nav = navigator;
+        if (Object.keys(options).length === 0) {
+            return nav.locks.request(name, () => callback());
+        }
+        return nav.locks.request(name, options, () => callback());
+    }
+    /**
+     * Query the current lock state. Useful for diagnostics and tests; do not gate
+     * critical-section logic on this — it's a snapshot, not a reservation.
+     */
+    query() {
+        this.ensureSupported();
+        return navigator.locks.query();
+    }
+    ensureSupported() {
+        super.ensureSupported();
+        if (!this.isSupported()) {
+            throw new Error('Web Locks API not supported in this browser');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebLocksService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebLocksService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebLocksService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Service wrapping `navigator.storage` (StorageManager API). Exposes:
+ * - `estimate()`: how much origin storage is in use vs available
+ * - `persist()`: ask the browser to make storage persistent (eviction-protected)
+ * - `persisted()`: check whether storage is currently persistent
+ */
+class StorageManagerService extends BrowserApiBaseService {
+    getApiName() {
+        return 'storage-manager';
+    }
+    isSupported() {
+        if (!this.isBrowserEnvironment())
+            return false;
+        const sm = navigator.storage;
+        return !!sm && typeof sm.estimate === 'function';
+    }
+    async estimate() {
+        this.ensureSupported();
+        const sm = navigator.storage;
+        const result = await sm.estimate();
+        return {
+            usage: result.usage ?? 0,
+            quota: result.quota ?? 0,
+            usageDetails: result
+                .usageDetails,
+        };
+    }
+    async persist() {
+        this.ensureSupported();
+        const sm = navigator.storage;
+        if (typeof sm.persist !== 'function')
+            return false;
+        return sm.persist();
+    }
+    async persisted() {
+        this.ensureSupported();
+        const sm = navigator.storage;
+        if (typeof sm.persisted !== 'function')
+            return false;
+        return sm.persisted();
+    }
+    ensureSupported() {
+        super.ensureSupported();
+        if (!this.isSupported()) {
+            throw new Error('StorageManager API not supported in this browser');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: StorageManagerService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: StorageManagerService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: StorageManagerService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Service wrapping `CompressionStream` and `DecompressionStream`.
+ *
+ * ```ts
+ * const cmp = inject(CompressionService);
+ * const compressed = await cmp.compress(jsonBytes, 'gzip');
+ * const original = await cmp.decompress(compressed, 'gzip');
+ * ```
+ */
+class CompressionService extends BrowserApiBaseService {
+    getApiName() {
+        return 'compression-streams';
+    }
+    isSupported() {
+        if (!this.isBrowserEnvironment())
+            return false;
+        const g = globalThis;
+        return typeof g.CompressionStream === 'function' && typeof g.DecompressionStream === 'function';
+    }
+    /** Compress a `Uint8Array`/`ArrayBuffer` using the given format. */
+    async compress(data, format = 'gzip') {
+        this.ensureSupported();
+        const g = globalThis;
+        const stream = new g.CompressionStream(format);
+        return this.runStream(data, stream);
+    }
+    /** Decompress a `Uint8Array`/`ArrayBuffer` using the given format. */
+    async decompress(data, format = 'gzip') {
+        this.ensureSupported();
+        const g = globalThis;
+        const stream = new g.DecompressionStream(format);
+        return this.runStream(data, stream);
+    }
+    /** Convenience: compress a UTF-8 string and return the compressed bytes. */
+    async compressString(value, format = 'gzip') {
+        return this.compress(new TextEncoder().encode(value), format);
+    }
+    /** Convenience: decompress bytes into a UTF-8 string. */
+    async decompressString(data, format = 'gzip') {
+        const bytes = await this.decompress(data, format);
+        return new TextDecoder().decode(bytes);
+    }
+    ensureSupported() {
+        super.ensureSupported();
+        if (!this.isSupported()) {
+            throw new Error('Compression Streams API not supported in this browser');
+        }
+    }
+    async runStream(data, stream) {
+        const writer = stream.writable.getWriter();
+        const writePromise = writer.write(data instanceof Uint8Array ? data : new Uint8Array(data));
+        const closePromise = writer.close();
+        const reader = stream.readable.getReader();
+        const chunks = [];
+        let total = 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = value;
+            chunks.push(chunk);
+            total += chunk.byteLength;
+        }
+        await writePromise;
+        await closePromise;
+        const result = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CompressionService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CompressionService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CompressionService, decorators: [{
+            type: Injectable
+        }] });
+
 // Common types for browser APIs
 
 function injectPageVisibility() {
@@ -3163,6 +3464,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') {
@@ -3389,6 +3941,18 @@ function provideGamepad() {
     return makeEnvironmentProviders([GamepadService]);
 }
 
+function provideWebLocks() {
+    return makeEnvironmentProviders([WebLocksService]);
+}
+
+function provideStorageManager() {
+    return makeEnvironmentProviders([StorageManagerService]);
+}
+
+function provideCompression() {
+    return makeEnvironmentProviders([CompressionService]);
+}
+
 function provideMediaApis() {
     return makeEnvironmentProviders([PermissionsService, CameraService, MediaDevicesService]);
 }
@@ -3484,4 +4048,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, CompressionService, ConnectionRegistryBaseService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PerformanceObserverService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, StorageManagerService, VibrationService, WebAudioService, WebLocksService, 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, provideCompression, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideStorageManager, provideVibration, provideWebAudio, provideWebLocks, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version };