@pexip/media 19.1.0 → 20.0.1

package/CHANGELOG.md

@@ -1,5 +1,78 @@
 # @pexip/media
 
+## 20.0.1
+
+### Patch Changes
+
+- 091652a: emit `onAudioMuteStateChanged` and `onVideoMuteStateChanged` each
+  time we call `syncMuteState`
+  - @pexip/media-control@20.0.1
+  - @pexip/media-processor@20.0.1
+  - @pexip/signal@16.8.0
+  - @pexip/utils@17.0.0
+
+## 20.0.0
+
+### Major Changes
+
+- 2bfd9e1: Adds esm entry points.
+- c975587: `dynamicProcessingDimensions` is a func.
+- 7679b89: Removes `adjustResolution`.
+
+### Minor Changes
+
+- dd5a4eb: Adds optional `gpuAPI` getter, sets the transformer backend when
+  opened.
+- 34bf3dd: Add isVideoStreamTrackProcessorAPIs
+- 5855473: Updates the segmenter processing width and height based on the track
+  settings if `dynamicProcessingDimensions` is `true` in `videoProcessor`.
+- 3555d9d: Adds `build:sourcemap` script.
+- 7d94f5c: Take unauthorized device into account
+- ed53b05: Upgrade Typescript
+
+### Patch Changes
+
+- 4146978: Bump logger proxy set to info level
+- 0beec97: Fix mergeStatus to take requesting single device into consideration
+
+  When changing 1 device should not affect another type of device
+
+- 67a18d0: Use recommended linter rules
+- e1882e7: Request media only when there is no prompt permission
+- 3882f98: No unused imports
+- 50d0af0: Assert track and input
+- 5adb1aa: Update according Logger changes
+- 79c52c9: No signals reuse for clone
+- 43d0b9c: Always use the merged constraints
+- 6470495: Fix applyFeatures
+- 6d68da2: Stop processing non-live track
+- 58ecca1: Fix mergeStatus fallback case
+- e76a15e: Migrate to biome linter
+- Updated dependencies [2bfd9e1]
+- Updated dependencies [4fe77de]
+- Updated dependencies [b0d8af9]
+- Updated dependencies [2bbff64]
+- Updated dependencies [4baa8a4]
+- Updated dependencies [db3a370]
+- Updated dependencies [4ea0492]
+- Updated dependencies [3555d9d]
+- Updated dependencies [d3909ed]
+- Updated dependencies [0416d6c]
+- Updated dependencies [1601985]
+- Updated dependencies [7d94f5c]
+- Updated dependencies [3cb5aee]
+- Updated dependencies [fa06b8b]
+- Updated dependencies [84956b8]
+- Updated dependencies [ed53b05]
+- Updated dependencies [5855473]
+- Updated dependencies [941363c]
+- Updated dependencies [d681fd3]
+- Updated dependencies [e76a15e]
+  - @pexip/media-processor@20.0.0
+  - @pexip/media-control@20.0.0
+  - @pexip/utils@17.0.0
+  - @pexip/signal@16.8.0
+
 ## 19.1.0
 
 ### Minor Changes

package/dist/audioMixingProcessor.d.ts

@@ -10,7 +10,7 @@ interface AudioStreamProcessorProps {
 declare const FEATURE_KEYS: ['mixWithAdditionalMedia'];
 type FeaturePropKeys = (typeof FEATURE_KEYS)[number];
 type FeatureProps = Pick<AudioStreamProcessorProps, FeaturePropKeys>;
-export declare const updateFeatureProps: (constraints: MediaDeviceRequest['audio'], props: FeatureProps) => FeatureProps;
+export declare const updateFeatureProps: (constraints: MediaDeviceRequest["audio"], props: FeatureProps) => FeatureProps;
 /**
  * Create a Audio Mixing Processor and will own the stream passed-in
  */

package/dist/audioMixingProcessor.js

@@ -12,7 +12,8 @@ export const updateFeatureProps = (constraints, props) => {
         const [feature] = extracted[key];
         if (feature !== undefined && props[key] !== feature) {
             props[key] = feature;
-            return { ...accm, [key]: feature };
+            accm[key] = feature;
+            return accm;
         }
         return accm;
     }, {});
@@ -155,11 +156,10 @@ export const createAudioMixingProcess = (getCurrentMedia, label = PROCESSOR_LABE
             overrideMute: true,
             mute: toMute => {
                 prevMediaTrack.mute(toMute);
-                mainSource.node?.mediaStream
-                    .getAudioTracks()
-                    .forEach(track => {
+                for (const track of mainSource.node?.mediaStream.getAudioTracks() ??
+                    []) {
                     track.enabled = !toMute;
-                });
+                }
             },
             get muted() {
                 return (

package/dist/audioProcessor.d.ts

@@ -78,7 +78,7 @@ interface AudioStreamProcessorProps {
 declare const FEATURE_KEYS: ['denoise', 'vad', 'asd', 'contentHint'];
 type FeaturePropKeys = (typeof FEATURE_KEYS)[number];
 type FeatureProps = Pick<AudioStreamProcessorProps, FeaturePropKeys>;
-export declare const updateFeatureProps: (constraints: MediaDeviceRequest['audio'], props: FeatureProps) => FeatureProps;
+export declare const updateFeatureProps: (constraints: MediaDeviceRequest["audio"], props: FeatureProps) => FeatureProps;
 /**
  * Create a Audio Stream Processor and will own the stream passed-in
  */

package/dist/audioProcessor.js

@@ -32,7 +32,8 @@ export const updateFeatureProps = (constraints, props) => {
                 const [[feature] = []] = extracted[key];
                 if (isAudioContentHint(feature) && props[key] !== feature) {
                     props[key] = feature;
-                    return { ...accm, [key]: feature };
+                    accm[key] = feature;
+                    return accm;
                 }
                 return accm;
             }
@@ -42,7 +43,8 @@ export const updateFeatureProps = (constraints, props) => {
                 const [feature] = extracted[key];
                 if (feature !== undefined && props[key] !== feature) {
                     props[key] = feature;
-                    return { ...accm, [key]: feature };
+                    accm[key] = feature;
+                    return accm;
                 }
                 return accm;
             }

package/dist/baseLogger.d.ts

@@ -9,7 +9,7 @@ export declare enum LogLevels {
     warn = 40,
     error = 50,
     fatal = 60,
-    silent
+    silent = 9007199254740991
 }
 export type LogLevelsString = keyof typeof LogLevels;
 export type LogMethods = {
@@ -21,14 +21,23 @@ export type LogMethods = {
  */
 export interface Logger extends LogMethods {
     /**
-     * Adds a value to the redaction set, which makes it replaced by [REDACTED] when logged to file.
+     * Add a pattern to the redactor and an optional mask for the redaction.
      *
-     * @remarks
-     * The redaction set is applied globally, and only applies to the log file, not console logs.
+     * @see {@link Redactor}
      *
-     * @param value - the string to redact
+     * @param value - The pattern to add.
+     * @param replaceTo - The mask to use for redaction.
      */
-    redact(value: string): void;
+    addRedactPattern(value: string, redactTo?: string): void;
+    /**
+     * Redact the provided string by replacing all occurrences of the patterns
+     * and return a new string with redacted values.
+     *
+     * @see {@link Redactor}
+     *
+     * @param text - The string to redact.
+     */
+    redact(text: string): string;
 }
 /**
  * Create a logger with console API, and map fatal to error, skipping trace

package/dist/baseLogger.js

@@ -6,8 +6,7 @@ export var LogLevels;
     LogLevels[LogLevels["warn"] = 40] = "warn";
     LogLevels[LogLevels["error"] = 50] = "error";
     LogLevels[LogLevels["fatal"] = 60] = "fatal";
-    // eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member -- needs infinity
-    LogLevels[LogLevels["silent"] = Number.MAX_SAFE_INTEGER] = "silent";
+    LogLevels[LogLevels["silent"] = 9007199254740991] = "silent";
 })(LogLevels || (LogLevels = {}));
 /**
  * Create a logger with console API, and map fatal to error, skipping trace
@@ -15,15 +14,22 @@ export var LogLevels;
  */
 export function createConsoleLogger() {
     return Object.freeze({
-        /* eslint-disable no-console -- set logger to console */
         fatal: (meta, message) => console.error(message, meta),
         error: (meta, message) => console.error(message, meta),
         warn: (meta, message) => console.warn(message, meta),
         info: (meta, message) => console.info(message, meta),
         debug: (meta, message) => console.debug(message, meta),
-        trace() { }, // Noop
-        silent() { }, // Noop
-        redact() { }, // Noop
-        /* eslint-enable no-console -- set logger to console */
+        trace() {
+            // Noop
+        },
+        silent() {
+            // Noop
+        },
+        redact(text) {
+            return text;
+        },
+        addRedactPattern() {
+            // Noop
+        },
     });
 }

package/dist/constants.d.ts

@@ -5,3 +5,4 @@ export declare const PROCESSOR_LABELS: Readonly<{
     AudioMixingProcessor: "AudioMixingProcessor";
 }>;
 export declare const GET_USER_MEDIA_TIMEOUT_MS = 10000;
+export declare const DEVICE_CHANGE_DEBOUNCE_TIMEOUT_MS = 500;

package/dist/constants.js

@@ -5,3 +5,4 @@ export const PROCESSOR_LABELS = Object.freeze({
     AudioMixingProcessor: 'AudioMixingProcessor',
 });
 export const GET_USER_MEDIA_TIMEOUT_MS = 10000;
+export const DEVICE_CHANGE_DEBOUNCE_TIMEOUT_MS = 500;

package/dist/displayMedia.d.ts

@@ -1,3 +1,3 @@
 import type { DisplayMediaOptions } from '@pexip/media-control';
-export declare const createGetDisplayMedia: (getDefaultConstraints: () => DisplayMediaOptions, getDisplayMedia?: MediaDevices['getDisplayMedia']) => (constraints?: DisplayMediaOptions) => Promise<MediaStream | undefined>;
+export declare const createGetDisplayMedia: (getDefaultConstraints: () => DisplayMediaOptions, getDisplayMedia?: MediaDevices["getDisplayMedia"]) => (constraints?: DisplayMediaOptions) => Promise<MediaStream | undefined>;
 export type GetDisplayMedia = ReturnType<typeof createGetDisplayMedia>;

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-export { createMedia } from './media';
-export { createAudioStreamProcess } from './audioProcessor';
-export { createVideoStreamProcess } from './videoProcessor';
-export * from './types';
-export { setLogger } from './logger';
+export * from './displayMedia';
 export * from './previewController';
-export * from './status';
 export * from './signals';
+export * from './status';
+export * from './typeGuard';
+export * from './types';
 export { applyContentHint } from './utils';
 export { createAudioMixingProcess } from './audioMixingProcessor';
-export * from './displayMedia';
+export { createAudioStreamProcess } from './audioProcessor';
+export { createMedia } from './media';
+export { createVideoStreamProcess } from './videoProcessor';
+export { setLogger } from './logger';

package/dist/index.js

@@ -1,11 +1,12 @@
-export { createMedia } from './media';
-export { createAudioStreamProcess } from './audioProcessor';
-export { createVideoStreamProcess } from './videoProcessor';
-export * from './types';
-export { setLogger } from './logger';
+export * from './displayMedia';
 export * from './previewController';
-export * from './status';
 export * from './signals';
+export * from './status';
+export * from './typeGuard';
+export * from './types';
 export { applyContentHint } from './utils';
 export { createAudioMixingProcess } from './audioMixingProcessor';
-export * from './displayMedia';
+export { createAudioStreamProcess } from './audioProcessor';
+export { createMedia } from './media';
+export { createVideoStreamProcess } from './videoProcessor';
+export { setLogger } from './logger';

package/dist/logger.js

@@ -30,11 +30,8 @@ export const createLogProxyHandler = (logger, name, scope) => {
             logger.debug({ scope, name, prop: p, value }, `called get ${name}[${String(p)}]`);
             return value;
         },
-        // eslint-disable-next-line max-params --- from lib.es2015 and log
         set: (target, p, value, receiver) => {
-            logger.debug(
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- it's a log call...
-            { scope, name, prop: p, value }, `called set ${name}[${String(p)}]`);
+            logger.info({ scope, name, prop: p, value }, `called set ${name}[${String(p)}]`);
             return Reflect.set(target, p, value, receiver);
         },
     };

package/dist/media.d.ts

@@ -1,4 +1,4 @@
-import type { IndexedDevices, MediaDeviceRequest, InputDevicePermission } from '@pexip/media-control';
+import type { IndexedDevices, MediaDeviceRequest, InputDevicePermission, InputConstraintSet } from '@pexip/media-control';
 import type { GetUserMediaProcess, Media, MediaController, MediaOptions, MediaSignals, MediaTrack } from './types';
 export interface MediaUpdaterOptions {
     getUserMedia: GetUserMediaProcess;
@@ -7,8 +7,12 @@ export interface MediaUpdaterOptions {
     onMediaTracksChanged: (media: Media, tracks: MediaTrack[]) => void;
     getInputDevicePermission?: () => Promise<InputDevicePermission>;
     signals?: MediaSignals;
+    getDefaultConstraints?: () => {
+        audio?: InputConstraintSet | false;
+        video?: InputConstraintSet | false;
+    };
 }
-export declare const createMediaUpdater: ({ getUserMedia, getCurrentDevices, shouldDiscardMedia: shouldDisgardMedia, onMediaTracksChanged, getInputDevicePermission, signals, }: MediaUpdaterOptions) => (constraints: MediaDeviceRequest, currentMedia: Media | undefined) => Promise<void>;
+export declare const createMediaUpdater: ({ getUserMedia, getCurrentDevices, shouldDiscardMedia: shouldDisgardMedia, onMediaTracksChanged, getInputDevicePermission, getDefaultConstraints, signals, }: MediaUpdaterOptions) => (constraints: MediaDeviceRequest, currentMedia: Media | undefined) => Promise<void>;
 /**
  * Create an object to interact with the media scream, which is usually used for
  * our main stream.

package/dist/media.js

@@ -1,17 +1,17 @@
-import { MediaEventType, createIndexedDevices, createStreamTrackEventSubscriptions, getDevices, getInputDevicePermissionState, isIndexedDevices, isRequestedResolution, mergeConstraints, subscribe, } from '@pexip/media-control';
+import { createIndexedDevices, createStreamTrackEventSubscriptions, getDevices, getInputDevicePermissionState, isIndexedDevices, isRequestedResolution, mergeConstraints, } from '@pexip/media-control';
 import { createAsyncQueue, isEmpty, assert } from '@pexip/utils';
 import { internalSignals } from './signals';
 import { UserMediaStatus } from './types';
 import { createModuleLogger, logger } from './logger';
 import { createGetUserMediaProcess, requestUserMediaWithRetry, } from './userMedia';
-import { AUDIO_SETTINGS_KEYS, MIXING_SETTINGS_KEYS, VIDEO_SETTINGS_KEYS, buildMedia, createMediaProcessor, diffSettings, getDevicesChanges, hasPtzFeature, mergeSettings, refineMediaConstraints, } from './utils';
-import { getPermissionStatus, isInitialPermissionsGranted } from './status';
+import { AUDIO_SETTINGS_KEYS, MIXING_SETTINGS_KEYS, PAN_TILT_ZOOM_SETTINGS_KEYS, VIDEO_SETTINGS_KEYS, buildMedia, createMediaProcessor, diffSettings, getDevicesChanges, getSettingsFromKeys, hasPtzFeature, isApplyingRenderEffect, mergeSettings, refineMediaConstraints, } from './utils';
+import { getPermissionStatus, isRequestPermissionNeeded } from './status';
 import { isMedia } from './typeGuard';
 import { updateFeatureProps as getVideoFeatures } from './videoProcessor';
 import { updateFeatureProps as getAudioFeatures } from './audioProcessor';
 import { updateFeatureProps as getMixingFeatures } from './audioMixingProcessor';
-import { GET_USER_MEDIA_TIMEOUT_MS } from './constants';
-export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDiscardMedia: shouldDisgardMedia, onMediaTracksChanged, getInputDevicePermission = getInputDevicePermissionState, signals, }) => {
+import { GET_USER_MEDIA_TIMEOUT_MS, DEVICE_CHANGE_DEBOUNCE_TIMEOUT_MS, } from './constants';
+export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDiscardMedia: shouldDisgardMedia, onMediaTracksChanged, getInputDevicePermission = getInputDevicePermissionState, getDefaultConstraints, signals, }) => {
     return async (constraints, currentMedia) => {
         const currentDevices = await getCurrentDevices();
         const permission = await getInputDevicePermission();
@@ -41,14 +41,26 @@ export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDisc
         const videoFeatures = getVideoFeatures(constraints.video, {});
         const audioFeatures = getAudioFeatures(constraints.audio, {});
         const mixingFeatures = getMixingFeatures(constraints.audio, {});
-        const hasRequestedResolution = ['blur', 'overlay'].includes(videoFeatures.videoSegmentation ?? '') || // Skip when there is a render effect to modify the video
+        const hasRequestedResolution = isApplyingRenderEffect(videoFeatures.videoSegmentation ?? 'none') || // Skip when there is a render effect to modify the video
             currentDevices.size('videoinput') === 0 || // Skip when no authorized video found
             isRequestedResolution(constraints.video, currentMedia?.getVideoTracks().at(0)?.getSettings());
-        const audioFeaturesChanged = diffSettings(AUDIO_SETTINGS_KEYS)(prevAudioSettings, audioFeatures);
-        const videoFeaturesChanged = diffSettings(VIDEO_SETTINGS_KEYS)(prevVideoSettings, videoFeatures);
-        const mixingFeaturesChanged = diffSettings(MIXING_SETTINGS_KEYS)(prevAudioSettings, mixingFeatures);
-        const ptzFeaturesChanges = hasPtzFeature() &&
-            diffSettings(['pan', 'tilt', 'zoom'])(prevVideoSettings, videoFeatures);
+        const defaultAudioSettings = getSettingsFromKeys(AUDIO_SETTINGS_KEYS, getDefaultConstraints?.().audio);
+        const audioFeaturesChanged = defaultAudioSettings === false
+            ? undefined
+            : diffSettings(AUDIO_SETTINGS_KEYS)(prevAudioSettings ?? defaultAudioSettings, audioFeatures);
+        const defaultVideoSettings = getSettingsFromKeys(VIDEO_SETTINGS_KEYS, getDefaultConstraints?.().video);
+        const videoFeaturesChanged = defaultVideoSettings === false
+            ? undefined
+            : diffSettings(VIDEO_SETTINGS_KEYS)(prevVideoSettings ?? defaultVideoSettings, videoFeatures);
+        const defaultMixingSettings = getSettingsFromKeys(MIXING_SETTINGS_KEYS, getDefaultConstraints?.().audio);
+        const mixingFeaturesChanged = defaultMixingSettings === false
+            ? undefined
+            : diffSettings(MIXING_SETTINGS_KEYS)(prevAudioSettings ?? defaultMixingSettings, mixingFeatures);
+        const defaultPTZSettings = getSettingsFromKeys(PAN_TILT_ZOOM_SETTINGS_KEYS, getDefaultConstraints?.().video);
+        const ptzFeaturesChanges = defaultPTZSettings === false
+            ? undefined
+            : hasPtzFeature() &&
+                diffSettings(PAN_TILT_ZOOM_SETTINGS_KEYS)(prevVideoSettings ?? defaultPTZSettings, videoFeatures);
         const audioRequest = refineMediaConstraints({
             kind: 'audioinput',
             request: constraints.audio,
@@ -62,9 +74,9 @@ export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDisc
             currentDevices,
             permission: permission.video,
             currentMediaTracks: currentMedia?.getVideoTracks() ?? [],
-            force: !hasRequestedResolution || Boolean(ptzFeaturesChanges),
+            force: !hasRequestedResolution || !isEmpty(ptzFeaturesChanges),
         });
-        if (audioRequest !== undefined || videoRequest !== undefined) {
+        if (audioRequest || videoRequest) {
             const media = await getUserMedia({
                 constraints: { audio: audioRequest, video: videoRequest },
                 originalConstraints: constraints,
@@ -80,6 +92,48 @@ export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDisc
                 ...(videoRequest ? media.getVideoTracks() : []),
             ]);
         }
+        else if (currentMedia?.status) {
+            // No media request, update status only
+            const anyAudioTrack = currentMedia
+                .getAudioTracks()
+                .some(track => track.track?.readyState === 'live');
+            const anyVideoTrack = currentMedia
+                .getVideoTracks()
+                .some(track => track.track?.readyState === 'live');
+            if (anyAudioTrack) {
+                if (anyVideoTrack) {
+                    currentMedia.status = UserMediaStatus.PermissionsGranted;
+                }
+                else if (currentDevices.size('videoinput') === 0) {
+                    currentMedia.status =
+                        UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices;
+                }
+                else {
+                    currentMedia.status =
+                        UserMediaStatus.PermissionsOnlyAudioinput;
+                }
+            }
+            else {
+                if (anyVideoTrack) {
+                    if (currentDevices.size('audioinput') === 0) {
+                        currentMedia.status =
+                            UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices;
+                    }
+                    else {
+                        currentMedia.status =
+                            UserMediaStatus.PermissionsOnlyVideoinput;
+                    }
+                }
+                else if (currentDevices.size('audioinput') === 0 &&
+                    currentDevices.size('videoinput') === 0) {
+                    currentMedia.status = UserMediaStatus.NoDevicesFound;
+                }
+                else {
+                    currentMedia.status = UserMediaStatus.PermissionsRejected;
+                }
+            }
+            logger.debug({ status: currentMedia.status }, 'Update existing media status');
+        }
         const audioDiff = constraints.audio &&
             audioRequest === undefined &&
             currentMedia?.getAudioTracks().at(0)
@@ -206,29 +260,25 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
         },
     });
     const getCurrentDevices = async () => {
-        if (props.devices.size()) {
-            return props.devices;
-        }
         props.devices = createIndexedDevices(await getDevices());
         return props.devices;
     };
     const syncMuteState = (tracks) => {
         const inputMuted = getMuteState();
         for (const track of tracks) {
-            const prevMuted = track.muted;
             switch (track.kind) {
                 case 'audioinput': {
                     track.mute(inputMuted.audio);
-                    if (prevMuted !== track.muted) {
-                        signals.onAudioMuteStateChanged?.emit(track.muted);
-                    }
+                    // FIXME: this can fire too often, but we want to make sure we signal initial state as well.
+                    // We should only fire this when needed.
+                    signals.onAudioMuteStateChanged?.emit(track.muted);
                     break;
                 }
                 case 'videoinput':
                     track.mute(inputMuted.video);
-                    if (prevMuted !== track.muted) {
-                        signals.onVideoMuteStateChanged?.emit(track.muted);
-                    }
+                    // FIXME: this can fire too often, but we want to make sure we signal initial state as well.
+                    // We should only fire this when needed.
+                    signals.onVideoMuteStateChanged?.emit(track.muted);
                     break;
                 default:
                     break;
@@ -277,10 +327,11 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
         getUserMedia: getUserMediaProcess,
         getCurrentDevices,
         shouldDiscardMedia: () => props.discardMedia,
+        getDefaultConstraints,
         onMediaTracksChanged: (media, tracks) => {
             // Sync mute state to input tracks
             syncMuteState(tracks);
-            tracks.forEach(track => {
+            for (const track of tracks) {
                 if (track.track) {
                     const unsubscribe = createStreamTrackEventSubscriptions(track.track, {
                         ended: track => {
@@ -291,7 +342,8 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
                         unmute: signals.onStreamTrackUnmuted?.emit,
                     });
                 }
-            });
+            }
+            logger.debug({ media, tracks }, 'Update media tracks');
             props.media = media;
             processAndUpdateMedia(media, tracks).catch((error) => {
                 if (error instanceof Error) {
@@ -337,13 +389,14 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
         queue.enqueue(async () => {
             const permission = await getInputDevicePermissionState();
             const status = getPermissionStatus(permission);
-            if (isInitialPermissionsGranted(status)) {
+            logger.info({ permission, status }, 'tryAndGetUserMedia');
+            if (!isRequestPermissionNeeded(status)) {
                 await updateMedia(mergeMediaConstraints(constraints));
             }
             else {
                 const currentDevices = await getCurrentDevices();
                 props.media = buildMedia({
-                    constraints,
+                    constraints: mergeMediaConstraints(constraints),
                     permission,
                     devices: currentDevices,
                     status,
@@ -354,34 +407,22 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
             }
         });
     };
-    // Media Control Event handlers
-    const handleNoInputs = (_availableDevices) => {
-        if (props.media) {
-            props.media.status = UserMediaStatus.NoDevicesFound;
+    let deviceChangeTimeoutId = 0;
+    const clearDeviceChangeTimeout = () => {
+        if (deviceChangeTimeoutId) {
+            clearTimeout(deviceChangeTimeoutId);
+            deviceChangeTimeoutId = 0;
         }
     };
-    const handleDeviceChange = (devices) => {
-        props.devices = createIndexedDevices(devices);
+    const handleDeviceChange = () => {
+        logger.debug('devicechange event triggered');
+        clearDeviceChangeTimeout();
+        deviceChangeTimeoutId = setTimeout(getCurrentDevices, DEVICE_CHANGE_DEBOUNCE_TIMEOUT_MS);
     };
     // Subscribe Media Events for devices
-    subscribe(event => {
-        switch (event.detail.type) {
-            case MediaEventType.NoInputDevices:
-                logger.debug(event.detail, 'NoInputDevices emitted');
-                handleNoInputs(event.detail.devices);
-                break;
-            case MediaEventType.DevicesFound:
-            case MediaEventType.DevicesLost:
-                logger.debug(event.detail, 'DevicesFound/Lost emitted');
-                handleDeviceChange([
-                    ...event.detail.authorizedDevices,
-                    ...event.detail.unauthorizedDevices,
-                ]);
-                break;
-            default:
-                break;
-        }
-    });
+    if ('mediaDevices' in navigator) {
+        navigator.mediaDevices.addEventListener('devicechange', handleDeviceChange);
+    }
     return {
         get updatingMedia() {
             return props.updatingMedia;

package/dist/previewController.js

@@ -21,7 +21,8 @@ const extractFeaturesToConstraints = (keysToLookFor, settings) => {
     }
     return keysToLookFor.reduce((set, key) => {
         if (settings[key] !== undefined) {
-            return { ...set, [key]: settings[key] };
+            // @ts-expect-error performance
+            set[key] = settings[key];
         }
         return set;
     }, {});
@@ -289,11 +290,9 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
         const { audio: previewAudio, video: previewVideo } = props.media?.getSettings() ?? { audio: {}, video: {} };
         if (force || hasChanges()) {
             const audioSettings = extractFeaturesToConstraints(AUDIO_SETTINGS_KEYS, previewAudio);
-            const videoSettings = extractFeaturesToConstraints(VIDEO_SETTINGS_KEYS, previewVideo);
             // Omit the width & height settings from the preview so that the one
             // from the main can be applied
-            delete videoSettings.width;
-            delete videoSettings.height;
+            const { width, height, ...videoSettings } = extractFeaturesToConstraints(VIDEO_SETTINGS_KEYS, previewVideo);
             logger.info({ audioInput, videoInput, audioSettings, videoSettings }, 'Apply changes to main');
             try {
                 await replaceMainStream({

package/dist/signals.d.ts

@@ -1,6 +1,6 @@
 import type { Signal, SignalVariant } from '@pexip/signal';
 import type { IndexedDevices } from '@pexip/media-control';
-import type { MediaSignals } from './types';
+import type { MediaSignals, MediaSignalsOptional } from './types';
 /**
  * Create a general signal with consistent scoped name
  *
@@ -8,7 +8,7 @@ import type { MediaSignals } from './types';
  * @param crucial - Signify if the signal is unmissable. @defaultValue true
  * @param variant - The variant of the signal @see Signal @defaultValue 'generic'
  */
-export declare const createMediaSignal: <T = undefined>(name: string, crucial?: boolean, variant?: SignalVariant) => Signal<T>;
+export declare const createMediaSignal: <T = undefined>(name: string, crucial?: boolean, variant?: Exclude<SignalVariant, "batched">) => Signal<T, T>;
 export declare const REQUIRED_SIGNAL_KEYS: readonly ["onMediaChanged", "onVAD", "onSilentDetected"];
 /**
  * Create and return all required and optional (if specified with `more`),
@@ -23,12 +23,12 @@ export declare const REQUIRED_SIGNAL_KEYS: readonly ["onMediaChanged", "onVAD",
  *
  * @see REQUIRED_SIGNAL_KEYS
  */
-export declare const createMediaSignals: <K extends "onAddTrack" | "onAudioMuteStateChanged" | "onTrackReleased" | "onDevicesChanged" | "onRemoveTrack" | "onStatusChanged" | "onVideoMuteStateChanged" | "onUpdatingMedia" | keyof import("./types").StreamTrackSignals | "onStreamTrackMutedFinal" | "onStreamTrackUnmutedFinal" | "onStreamTrackEndedFinal" | "onStreamTrackEnabledFinal">(more: K[], scope?: string) => Pick<Required<MediaSignals>, "onMediaChanged" | "onVAD" | "onSilentDetected" | K>;
+export declare const createMediaSignals: <K extends keyof MediaSignalsOptional>(more: K[], scope?: string) => Pick<Required<MediaSignals>, "onMediaChanged" | "onVAD" | "onSilentDetected" | K>;
 export type GeneratedMediaSignals<K extends keyof MediaSignals> = Pick<Required<MediaSignals>, K>;
 /**
  * Internal signals
  * @internal
  */
 export declare const internalSignals: {
-    onDevicesChanged: Signal<IndexedDevices>;
+    onDevicesChanged: Signal<IndexedDevices, IndexedDevices>;
 };

package/dist/signals.js

@@ -6,7 +6,9 @@ import { createSignal } from '@pexip/signal';
  * @param crucial - Signify if the signal is unmissable. @defaultValue true
  * @param variant - The variant of the signal @see Signal @defaultValue 'generic'
  */
-export const createMediaSignal = (name, crucial = true, variant = 'generic') => createSignal({
+export const createMediaSignal = (name, crucial = true, 
+// FIXME: need `schedule` function to support `batched` variant
+variant = 'generic') => createSignal({
     name: `media/${name}`,
     allowEmittingWithoutObserver: !crucial,
     variant,
@@ -31,10 +33,11 @@ export const REQUIRED_SIGNAL_KEYS = [
  */
 export const createMediaSignals = (more, scope = '') => {
     const signalScope = scope && [scope, ':'].join('');
-    return [...REQUIRED_SIGNAL_KEYS, ...more].reduce((signals, key) => ({
-        ...signals,
-        [key]: createMediaSignal(`${signalScope}${key}`),
-    }), {});
+    return [...REQUIRED_SIGNAL_KEYS, ...more].reduce((signals, key) => {
+        // @ts-expect-error
+        signals[key] = createMediaSignal(`${signalScope}${key}`);
+        return signals;
+    }, {});
 };
 /**
  * Internal signals