@pexip/media 18.4.0 → 19.0.0

package/dist/previewController.js

@@ -1,15 +1,14 @@
-import { getUserMedia, hasChangedInput, isMediaDeviceInfo, } from '@pexip/media-control';
-import { createAsyncQueue } from '@pexip/utils';
-import { UserMediaStatus } from './types';
-import { buildMedia, cloneMedia, createMediaPipeline, hasSettingsChanged, AUDIO_SETTINGS_KEYS, VIDEO_SETTINGS_KEYS, } from './utils';
+import { hasChangedInput, isMediaDeviceInfo, reverseDeviceId, } from '@pexip/media-control';
+import { createAsyncQueue, assert } from '@pexip/utils';
+import { AUDIO_SETTINGS_KEYS, VIDEO_SETTINGS_KEYS, createMediaProcessor, hasSettingsChanged, } from './utils';
 import { isMedia } from './typeGuard';
 import { createModuleLogger } from './logger';
-import { isInitial } from './status';
-import { createGetUserMediaProcess } from './userMedia';
-const DEFAULT_QUEUE_SIZE = 1;
-const DEFAULT_QUEUE_THROTTLE_MS = 500;
+import { createGetUserMediaProcess, requestUserMediaWithRetry, } from './userMedia';
+import { createMediaUpdater } from './media';
 const DEFAULT_QUEUE_DELAY_MS = 100;
 const DEFAULT_QUEUE_DROP_LAST = false;
+const DEFAULT_QUEUE_SIZE = 1;
+const DEFAULT_QUEUE_THROTTLE_MS = 500;
 const isPreviewInput = (value) => {
     if (isMediaDeviceInfo(value) || value === undefined) {
         return true;
@@ -33,18 +32,14 @@ const createEventHandler = (eventHandlers) => (key) => (callback) => {
         eventHandlers[key] = undefined;
     };
 };
-const getUM = async (constraints) => [
-    await getUserMedia(constraints),
-    UserMediaStatus.PermissionsGranted,
-];
 const createAudioVideoProcessingSettingsChangeDetector = (getCurrentMedia, getPreviewMedia) => {
     const hasAudioSettingsChanged = hasSettingsChanged(AUDIO_SETTINGS_KEYS);
     const hasVideoSettingsChanged = hasSettingsChanged(VIDEO_SETTINGS_KEYS);
     return () => {
         const currentMedia = getCurrentMedia?.();
         const previewMedia = getPreviewMedia();
-        const { audio: [mainAudio], video: [mainVideo], } = currentMedia?.getSettings() ?? { audio: [], video: [] };
-        const { audio: [previewAudio], video: [previewVideo], } = previewMedia.getSettings();
+        const { audio: mainAudio, video: mainVideo } = currentMedia?.getSettings() ?? { audio: {}, video: {} };
+        const { audio: previewAudio, video: previewVideo } = previewMedia?.getSettings() ?? { audio: {}, video: {} };
         const changed = hasAudioSettingsChanged(mainAudio, previewAudio) ||
             hasVideoSettingsChanged(mainVideo, previewVideo);
         return changed;
@@ -55,18 +50,11 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
     throttleInMS: DEFAULT_QUEUE_THROTTLE_MS,
     delayInMS: DEFAULT_QUEUE_DELAY_MS,
     dropLast: DEFAULT_QUEUE_DROP_LAST,
-}, processors, }) => {
+}, audioProcessors, videoProcessors, }) => {
     const queue = createAsyncQueue(queueOptions);
     const eventHandlers = {};
-    const release = () => {
-        if (isInitial(props.media.status)) {
-            props.discardMedia = true;
-        }
-        props.media = buildMedia(() => ({ release }));
-        return Promise.resolve();
-    };
     const internalProps = {
-        media: buildMedia(() => ({ release })),
+        media: undefined,
         updatingPreview: false,
         updatingMain: false,
         discardMedia: false,
@@ -127,30 +115,68 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
             }
         },
     });
-    const postMediaPipeline = createMediaPipeline(
-    // Ignore the type conversion between tuple and array
-    processors);
+    const getUserMedia = createGetUserMediaProcess({
+        getUserMedia: requestUserMediaWithRetry(() => Promise.resolve(getCurrentDevices())),
+        getCurrentDevices: () => Promise.resolve(getCurrentDevices()),
+    });
+    const processMedia = createMediaProcessor({
+        audioProcessors,
+        videoProcessors,
+        onProcessingError(error, track) {
+            logger.error({ error, track }, 'Failed to process media track');
+        },
+    });
+    const processAndUpdateMedia = async (media, tracks) => {
+        try {
+            const processedTracks = await processMedia(tracks);
+            for (const [idx, track] of processedTracks.entries()) {
+                const originTrack = tracks.at(idx);
+                assert(originTrack, 'Processed track should always has the original track in the same order');
+                // Only replace track when they are not the same
+                if (originTrack.id !== track.id) {
+                    media.removeTrack(originTrack);
+                    media.addTrack(track);
+                }
+            }
+        }
+        catch (error) {
+            logger.error({ error, tracks }, 'Failed to process media tracks');
+        }
+    };
+    const updateMediaProcess = createMediaUpdater({
+        getUserMedia,
+        getCurrentDevices: () => Promise.resolve(getCurrentDevices()),
+        shouldDiscardMedia: () => props.discardMedia,
+        onMediaTracksChanged: (media, tracks) => {
+            props.media = media;
+            queue.enqueue(async () => {
+                await processAndUpdateMedia(media, tracks);
+            });
+        },
+    });
     const initFromMain = (mainMedia) => {
-        if (!mainMedia.stream) {
+        if (!mainMedia?.stream) {
             return;
         }
-        postMediaPipeline
-            .execute(cloneMedia(mainMedia))
-            .then(media => {
-            props.media = media;
-        })
-            .catch((error) => {
+        try {
+            const clonedMedia = mainMedia.clone();
+            props.media = clonedMedia;
+            queue.enqueue(async () => {
+                await processAndUpdateMedia(clonedMedia, clonedMedia.getTracks());
+            });
+            props.audioInput = mainMedia.audioInput;
+            props.videoInput = mainMedia.videoInput;
+            props.originalMainAudioInput = mainMedia.audioInput;
+        }
+        catch (error) {
             logger.error({ error }, 'Failed to post process media');
-        })
-            .finally(() => {
+        }
+        finally {
             props.initialized = true;
             if (props.discardMedia) {
-                void props.media.release();
+                void props.media?.release();
             }
-        });
-        props.audioInput = mainMedia.audioInput;
-        props.videoInput = mainMedia.videoInput;
-        props.originalMainAudioInput = mainMedia.audioInput;
+        }
     };
     const mainMedia = getCurrentMedia();
     if (mainMedia?.stream) {
@@ -165,31 +191,29 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
         await updateMainStream(constraints);
         props.updatingMain = false;
     };
-    const mediaPipeline = createMediaPipeline(() => [
-        createGetUserMediaProcess(getUM, getCurrentDevices, {
-            initialMedia: props.media,
-            scope: 'PreviewStreamController',
-        }),
-        ...processors,
-    ]);
     const updatePreviewMedia = async (constraints) => {
         logger.debug({ constraints }, 'Requesting a new preview stream');
-        await props.media?.release();
-        const media = await mediaPipeline.execute(constraints);
-        if (props.discardMedia) {
-            logger.debug('Discard media');
-            return await media.release();
+        await updateMediaProcess(constraints, props.media);
+        logger.debug({ media: props.media }, 'Preview media updated');
+    };
+    const releaseAudio = async () => {
+        for (const track of props.media?.getAudioTracks() ?? []) {
+            await track.release();
+        }
+    };
+    const releaseVideo = async () => {
+        for (const track of props.media?.getVideoTracks() ?? []) {
+            await track.release();
         }
-        props.media = media;
     };
     const updateAudioInput = async (input) => {
-        props.audioInput = input;
-        const request = {
-            audio: { device: { exact: input } },
-            video: props.videoInput,
-        };
+        const request = { audio: { device: { exact: input } } };
         try {
+            props.audioInput = input;
             props.updatingPreview = true;
+            if (props.audioInput === undefined) {
+                return await releaseAudio();
+            }
             await updatePreviewMedia(request);
         }
         catch (error) {
@@ -227,13 +251,13 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
         }
     };
     const updateVideoInput = async (input) => {
-        props.videoInput = input;
         try {
+            props.videoInput = input;
             props.updatingPreview = true;
-            await updatePreviewMedia({
-                audio: props.audioInput,
-                video: { device: { exact: input } },
-            });
+            if (input === undefined) {
+                return await releaseVideo();
+            }
+            return await updatePreviewMedia({ video: { device: { exact: input } } });
         }
         catch (error) {
             if (error instanceof Error) {
@@ -248,7 +272,7 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
     };
     const cleanup = async () => {
         logger.debug('Cleanup preview controller');
-        await props.media.release();
+        await props.media?.release();
         cleanUpMainSubscription();
         props.audioInput = undefined;
         props.videoInput = undefined;
@@ -262,7 +286,7 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
         hasAudioVideoProcessingSettingsChanged();
     const applyChanges = async (force = false) => {
         const { audioInput, videoInput } = props;
-        const { audio: [previewAudio], video: [previewVideo], } = props.media.getSettings();
+        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);
@@ -273,8 +297,12 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
             logger.info({ audioInput, videoInput, audioSettings, videoSettings }, 'Apply changes to main');
             try {
                 await replaceMainStream({
-                    audio: { device: audioInput, ...audioSettings },
-                    video: { device: videoInput, ...videoSettings },
+                    audio: audioInput
+                        ? { device: audioInput, ...audioSettings }
+                        : false,
+                    video: videoInput
+                        ? { device: videoInput, ...videoSettings }
+                        : false,
                 });
                 props.originalMainAudioInput = props.audioInput;
             }
@@ -321,7 +349,10 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
             }
         }
     };
-    const updateInput = (hasChanged, updater) => (input) => {
+    const updateInput = (hasChanged, updater) => (id) => {
+        const [input] = id
+            ? getCurrentDevices().get(reverseDeviceId(id))
+            : [];
         if (hasChanged(input)) {
             queue.enqueue(async () => {
                 await updater(input);

package/dist/signals.d.ts

@@ -1,4 +1,5 @@
 import type { Signal, SignalVariant } from '@pexip/signal';
+import type { IndexedDevices } from '@pexip/media-control';
 import type { MediaSignals } from './types';
 /**
  * Create a general signal with consistent scoped name
@@ -22,4 +23,12 @@ export declare const REQUIRED_SIGNAL_KEYS: readonly ["onMediaChanged", "onVAD",
  *
  * @see REQUIRED_SIGNAL_KEYS
  */
-export declare const createMediaSignals: <K extends "onDevicesChanged" | "onStatusChanged" | "onAudioMuteStateChanged" | "onVideoMuteStateChanged" | keyof import("./types").StreamTrackSignals>(more: K[], scope?: string) => Pick<Required<MediaSignals>, "onMediaChanged" | "onVAD" | "onSilentDetected" | K>;
+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 type GeneratedMediaSignals<K extends keyof MediaSignals> = Pick<Required<MediaSignals>, K>;
+/**
+ * Internal signals
+ * @internal
+ */
+export declare const internalSignals: {
+    onDevicesChanged: Signal<IndexedDevices>;
+};

package/dist/signals.js

@@ -36,3 +36,12 @@ export const createMediaSignals = (more, scope = '') => {
         [key]: createMediaSignal(`${signalScope}${key}`),
     }), {});
 };
+/**
+ * Internal signals
+ * @internal
+ */
+export const internalSignals = {
+    onDevicesChanged: createSignal({
+        name: 'media/devicesChanged',
+    }),
+};

package/dist/status.d.ts

@@ -32,5 +32,8 @@ export declare const isDeviceInUse: UserMediaValidator;
 export declare const isDevicesInUse: UserMediaValidator;
 export declare const isVideoDeviceInUse: UserMediaValidator;
 export declare const toDeniedDevices: (status?: UserMediaStatus) => DeniedDevices | undefined;
-export declare const getPermissionStatus: (getPermissionState?: (anyActiveStream?: boolean | undefined) => Promise<import("@pexip/media-control").InputDevicePermission>) => Promise<UserMediaStatus.Initial | UserMediaStatus.InitialPermissionsGranted | UserMediaStatus.InitialPermissionsNotGranted | UserMediaStatus.InitialPermissionsVideoInputDenied | UserMediaStatus.InitialPermissionsAudioInputDenied | UserMediaStatus.InitialPermissionsVideoInputGranted | UserMediaStatus.InitialPermissionsAudioInputGranted | UserMediaStatus.InitialPermissionsGrantedVideoInputDenied | UserMediaStatus.InitialPermissionsGrantedAudioInputDenied | UserMediaStatus.PermissionsRejected>;
-export declare const deriveInitialPermissionStatus: (prevStatus: UserMediaStatus, getPermissionState?: (anyActiveStream?: boolean | undefined) => Promise<import("@pexip/media-control").InputDevicePermission>) => Promise<UserMediaStatus>;
+export declare const getPermissionStatus: ({ audio, video, }: {
+    audio: PermissionState;
+    video: PermissionState;
+}) => UserMediaStatus.Initial | UserMediaStatus.InitialPermissionsGranted | UserMediaStatus.InitialPermissionsNotGranted | UserMediaStatus.InitialPermissionsVideoInputDenied | UserMediaStatus.InitialPermissionsAudioInputDenied | UserMediaStatus.InitialPermissionsVideoInputGranted | UserMediaStatus.InitialPermissionsAudioInputGranted | UserMediaStatus.InitialPermissionsGrantedVideoInputDenied | UserMediaStatus.InitialPermissionsGrantedAudioInputDenied | UserMediaStatus.PermissionsRejected;
+export declare const deriveInitialPermissionStatus: (prevStatus: UserMediaStatus, getPermissionState?: (anyActiveAudioTrack?: boolean | undefined, anyActiveVideoTrack?: boolean | undefined, getDevices?: (() => Promise<MediaDeviceInfo[]>) | undefined) => Promise<import("@pexip/media-control").InputDevicePermission>) => Promise<UserMediaStatus>;

package/dist/status.js

@@ -137,8 +137,7 @@ export const toDeniedDevices = (status) => {
         return DeniedDevices.Both;
     }
 };
-export const getPermissionStatus = async (getPermissionState = getInputDevicePermissionState) => {
-    const { audio, video } = await getPermissionState();
+export const getPermissionStatus = ({ audio, video, }) => {
     if (audio === 'denied') {
         if (video === 'denied') {
             return UserMediaStatus.PermissionsRejected;
@@ -196,5 +195,6 @@ export const deriveInitialPermissionStatus = async (prevStatus, getPermissionSta
     if (prevStatus === UserMediaStatus.DevicesInUse) {
         return UserMediaStatus.InitialPermissionsGranted;
     }
-    return await getPermissionStatus(getPermissionState);
+    const permission = await getPermissionState();
+    return getPermissionStatus(permission);
 };

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { InputConstraintSet, MediaDeviceInfoLike, MediaDeviceRequest } from '@pexip/media-control';
+import type { IndexedDevices, InputConstraintSet, InputDeviceConstraint, MediaDeviceInfoLike, MediaDeviceRequest } from '@pexip/media-control';
 import type { RendererOptions, RenderEffects, Segmenter, SegmentationModel } from '@pexip/media-processor';
 import type { Signal } from '@pexip/signal';
 export type Unsubscribe = () => void;
@@ -22,8 +22,8 @@ export interface ExtendedMediaTrackSettings extends MediaTrackSettings {
 }
 export type ExtendedMediaTrackSettingsKey = keyof ExtendedMediaTrackSettings;
 export interface MediaSettings {
-    audio: ExtendedMediaTrackSettings[];
-    video: ExtendedMediaTrackSettings[];
+    audio?: ExtendedMediaTrackSettings;
+    video?: ExtendedMediaTrackSettings;
 }
 /**
  * URL links needed for creating a denoise node for audio processing
@@ -44,29 +44,26 @@ export interface DenoiseParams {
 }
 export interface MediaAttributes {
     /**
-     * The constraints used to request the media
-     */
-    constraints?: MediaDeviceRequest;
-    /**
-     * The devices used for the media
+     * Indicating whether the media is active
+     *
+     * A stream is considered active if at least one of its MediaStreamTracks
+     * does not have its property MediaStreamTrack.readyState set to ended.
+     * Once every track has ended, the stream's active property becomes false.
      */
-    devices: MediaDeviceInfoLike[];
+    readonly active: boolean;
     /**
-     * Media stream for the media
+     * A string containing a 36-character universally unique identifier (UUID)
+     * for the object.
      */
-    stream?: MediaStream;
+    readonly id: string;
     /**
-     * The raw stream obtained from the `getUserMedia` API
+     * The devices used for the media
      */
-    rawStream?: MediaStream;
+    devices: IndexedDevices;
     /**
-     * Audio input device is used for the audio track from the current stream
+     * Media stream for the media
      */
-    audioInput?: MediaDeviceInfoLike;
-    /**
-     * Video input device is used for the video track from the current stream
-     */
-    videoInput?: MediaDeviceInfoLike;
+    stream: MediaStream;
     /**
      * The audio input device which is expected to be used for the current
      * stream based on the provided constraints
@@ -91,6 +88,14 @@ export interface MediaAttributes {
      * `undefined` means there is no such track from the stream
      */
     videoMuted: boolean | undefined;
+    /**
+     * Audio input device is used for the audio track from the current stream
+     */
+    audioInput?: MediaDeviceInfoLike;
+    /**
+     * Video input device is used for the video track from the current stream
+     */
+    videoInput?: MediaDeviceInfoLike;
 }
 export interface Media extends MediaAttributes {
     /**
@@ -109,19 +114,95 @@ export interface Media extends MediaAttributes {
      * Release the media resources, e.g. camera/microphone
      */
     release(): Promise<void>;
+    getConstraints(): MediaDeviceRequest;
+    setOriginalConstraints(constraints: MediaDeviceRequest): void;
+    getOriginalConstraints(): MediaDeviceRequest;
+    isAudioInputUnavailable(): boolean;
+    isVideoInputUnavailable(): boolean;
+    requestedAudio(): boolean;
+    requestedVideo(): boolean;
     getSettings(): MediaSettings;
-    toJSON?: () => unknown;
+    toJSON(): unknown;
+    getTracks(): MediaTrack[];
+    getAudioTracks(): MediaTrack[];
+    getVideoTracks(): MediaTrack[];
+    addTrack(track: MediaTrack): void;
+    removeTrack(track: MediaTrack): void;
+    clone(): Media;
 }
-export type Process<T> = (a: T) => Promise<Media>;
-export type MediaProcessor = Process<Promise<Media>>;
-/**
- * A media pipeline to get and process media
- */
-export type Pipeline<T = MediaDeviceRequest> = [
-    Process<T>,
-    ...MediaProcessor[]
-];
-export type ProcessMedia = (media: Media) => undefined | Media;
+export interface MediaInit {
+    constraints: MediaDeviceRequest;
+    permission: {
+        audio: PermissionState;
+        video: PermissionState;
+    };
+    originalConstraints?: MediaDeviceRequest;
+    tracks: MediaTrack[];
+    devices: IndexedDevices;
+    status: UserMediaStatus;
+    stream: MediaStream | undefined;
+    signals?: MediaSignals;
+}
+export interface MediaTrack {
+    /**
+     * A unique identifier for the track same as `MediaStreamTrack.id` if
+     * `track` is available otherwise it uses the `id` from the construction or the
+     * `kind`. @see MediaTrackInit
+     */
+    id: string;
+    kind: 'audioinput' | 'videoinput';
+    label?: string;
+    previousMediaTrack?: MediaTrack;
+    /**
+     * The MediaStreamTrack object representing the track
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack
+     */
+    track?: MediaStreamTrack;
+    /**
+     * The `MediaDeviceInfo` object representing the device that the track is
+     * connected to. @see https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo
+     */
+    input?: MediaDeviceInfoLike;
+    /**
+     * The `MediaDeviceInfo` object representing the device that the track is
+     * expected to be connected to. @see https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo
+     */
+    expectedInput?: MediaDeviceInfoLike;
+    /**
+     * The current mute state of the track. `undefined` means the track is not available
+     */
+    muted?: boolean;
+    /**
+     * The source track that it is originated from
+     */
+    source: MediaTrack;
+    mute(toMute: boolean): void;
+    getSettings(): ExtendedMediaTrackSettings;
+    getConstraints(): InputDeviceConstraint;
+    applyConstraints(constraints: InputDeviceConstraint): Promise<void>;
+    release(): Promise<void>;
+    clone(): MediaTrack;
+    toJSON(): unknown;
+}
+export interface MediaTrackInit extends Partial<MediaTrack> {
+    kind: 'audioinput' | 'videoinput';
+    input: MediaDeviceInfoLike | undefined;
+    expectedInput?: MediaDeviceInfoLike | undefined;
+    constraints: InputDeviceConstraint;
+    overrideMute?: boolean;
+    signals?: MediaSignals;
+}
+export type Process<T> = (a: T) => Promise<MediaTrack>;
+export type TrackProcessor = Process<MediaTrack>;
+export type GetUserMediaProcess = (request: {
+    constraints: MediaDeviceRequest;
+    originalConstraints: MediaDeviceRequest;
+    permission: {
+        audio: PermissionState;
+        video: PermissionState;
+    };
+    currentMedia: Media | undefined;
+}) => Promise<Media>;
 /**
  * Use which processor API to process the stream track
  * `stream` - Use MediaStreamTrackProcessor, when available
@@ -361,7 +442,8 @@ export interface MediaOptions {
     /**
      * Media Processors
      */
-    mediaProcessors: MediaProcessor[];
+    audioProcessors: TrackProcessor[];
+    videoProcessors: TrackProcessor[];
     /**
      * A function to get the devices' mute state
      */
@@ -378,25 +460,27 @@ export interface MediaProps {
     /**
      * Current media
      */
-    media: Media;
+    media?: Media;
     /**
      * Current device
      */
-    devices: MediaDeviceInfoLike[];
+    devices: IndexedDevices;
     /**
      * When should we discard the requested MediaStream
      */
     discardMedia: boolean;
+    updatingMedia: boolean;
 }
 export interface MediaController {
+    readonly updatingMedia: boolean;
     /**
      * Current Media
      */
-    media: Media;
+    readonly media?: Media;
     /**
      * Current device list
      */
-    devices: MediaDeviceInfoLike[];
+    readonly devices: IndexedDevices;
     /**
      * Execute the media pipeline immediately with provided constraints
      *
@@ -454,18 +538,29 @@ export interface StreamTrackSignals {
      */
     onStreamTrackEnabled: Signal<MediaStreamTrack>;
 }
+/**
+ * Track state signals that used for the final track that the media pipeline
+ * produced
+ */
+export type StreamTrackSignalFinals = {
+    [key in keyof StreamTrackSignals as `${key}Final`]: Signal<MediaStreamTrack>;
+};
 export interface MediaChangesSignals {
-    onDevicesChanged: Signal<MediaDeviceInfoLike[]>;
+    onAddTrack: Signal<MediaStreamTrack>;
+    onAudioMuteStateChanged: Signal<boolean | undefined>;
+    onTrackReleased: Signal<MediaStreamTrack>;
+    onDevicesChanged: Signal<IndexedDevices>;
+    onMediaChanged: Signal<Media | undefined>;
+    onRemoveTrack: Signal<MediaStreamTrack>;
     onStatusChanged: Signal<UserMediaStatus>;
-    onMediaChanged: Signal<Media>;
-    onAudioMuteStateChanged: Signal<boolean>;
-    onVideoMuteStateChanged: Signal<boolean>;
+    onVideoMuteStateChanged: Signal<boolean | undefined>;
+    onUpdatingMedia: Signal<boolean>;
 }
 export interface AudioDetectionSignals {
     onVAD: Signal<undefined>;
     onSilentDetected: Signal<boolean>;
 }
-export type MediaSignalsOptional = Pick<Partial<MediaChangesSignals>, 'onDevicesChanged' | 'onStatusChanged' | 'onAudioMuteStateChanged' | 'onVideoMuteStateChanged'> & Partial<StreamTrackSignals>;
+export type MediaSignalsOptional = Omit<Partial<MediaChangesSignals>, 'onMediaChanged'> & Partial<StreamTrackSignals> & Partial<StreamTrackSignalFinals>;
 export type MediaSignalsRequired = Pick<MediaChangesSignals, 'onMediaChanged'> & AudioDetectionSignals;
 export type MediaSignals = MediaSignalsRequired & MediaSignalsOptional;
 export declare enum DeniedDevices {

package/dist/userMedia.d.ts

@@ -1,16 +1,17 @@
-import type { MediaDeviceRequest, MediaDeviceInfoLike } from '@pexip/media-control';
-import type { Process, Media } from './types';
+import type { MediaDeviceRequest, IndexedDevices } from '@pexip/media-control';
+import type { GetUserMediaProcess, MediaSignals } from './types';
 import { UserMediaStatus } from './types';
 import { makeDeriveDeviceStatus } from './utils';
 export type UserMedia = [MediaStream | undefined, UserMediaStatus];
 export type GetUserMedia<T extends Promise<Iterable<unknown>> = Promise<UserMedia>> = (constraints: MediaDeviceRequest) => T;
+export type GetCurrentDevices = () => Promise<IndexedDevices>;
 export declare const toErrorDeviceStatus: (error: Error, deriveDeviceStatus: ReturnType<typeof makeDeriveDeviceStatus>) => UserMediaStatus;
 export declare const mapErrorStatus: (status: UserMediaStatus) => (constraints: MediaDeviceRequest) => UserMediaStatus;
 export declare const toSameDeviceStatus: ({ audio, video, }: {
     audio: boolean;
     video: boolean;
 }) => UserMediaStatus.PermissionsGranted | UserMediaStatus.PermissionsGrantedFallback | UserMediaStatus.PermissionsGrantedFallbackAudioinput | UserMediaStatus.PermissionsGrantedFallbackVideoinput;
-export declare const toOnlyDeviceStatus: (kind: Extract<MediaDeviceKind, 'audioinput' | 'videoinput'>, matched: boolean, devices: MediaDeviceInfoLike[]) => UserMediaStatus.PermissionsOnlyAudioinput | UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices | UserMediaStatus.PermissionsOnlyAudioinputFallback | UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices | UserMediaStatus.PermissionsOnlyVideoinput | UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices | UserMediaStatus.PermissionsOnlyVideoinputFallback | UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices;
+export declare const toOnlyDeviceStatus: (kind: 'audioinput' | 'videoinput', matched: boolean, devices: IndexedDevices) => UserMediaStatus.PermissionsOnlyAudioinput | UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices | UserMediaStatus.PermissionsOnlyAudioinputFallback | UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices | UserMediaStatus.PermissionsOnlyVideoinput | UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices | UserMediaStatus.PermissionsOnlyVideoinputFallback | UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices;
 /**
  * Try to come up with an error level according to provided UserMediaStatus and
  * MediaDeviceRequest
@@ -20,19 +21,20 @@ export declare const toOnlyDeviceStatus: (kind: Extract<MediaDeviceKind, 'audioi
  * @param constraints - The constraints used for the request
  */
 export declare const deriveErrorLevel: (error: Error, status: UserMediaStatus, constraints: MediaDeviceRequest) => "error" | "warn";
-export declare const requestUserMedia: (currentDevices?: MediaDeviceInfoLike[], getMedia?: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>) => GetUserMedia;
+export declare const requestUserMedia: (getCurrentDevices: GetCurrentDevices, getMedia?: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>) => GetUserMedia;
 export declare const mergeNoDeviceStatus: (constraints: MediaDeviceRequest, anyDevices: {
     audio: boolean;
     video: boolean;
 }, status: UserMediaStatus) => UserMediaStatus;
-export declare const requestUserMediaWithRetry: (currentDevices?: MediaDeviceInfoLike[], createRequestUserMedia?: (currentDevices?: MediaDeviceInfoLike[], getMedia?: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>) => GetUserMedia) => GetUserMedia;
+export declare const requestUserMediaWithRetry: (getCurrentDevices: GetCurrentDevices, createRequestUserMedia?: (getCurrentDevices: GetCurrentDevices, getMedia?: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>) => GetUserMedia, gUM?: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>) => GetUserMedia;
 interface Options {
-    initialMedia: Media;
+    getUserMedia: GetUserMedia;
+    getCurrentDevices: GetCurrentDevices;
+    signals?: MediaSignals;
     scope?: string;
 }
-type CreateGetUserMediaProcess = (getUserMedia: GetUserMedia, getCurrentDevices: () => MediaDeviceInfoLike[], options: Options) => Process<MediaDeviceRequest>;
 /**
  * A process to get user media
  */
-export declare const createGetUserMediaProcess: CreateGetUserMediaProcess;
+export declare const createGetUserMediaProcess: ({ getUserMedia, getCurrentDevices, signals, scope, }: Options) => GetUserMediaProcess;
 export {};