@livedigital/client 3.58.0 → 3.59.0-release-june-fixes.2

package/dist/Client.d.ts

@@ -91,13 +91,14 @@ declare class Client {
     get scoresCalculator(): ScoresCalculator;
     /**
      * Обнаруживает доступные устройства ввода и обновляет внутренний список камер и микрофонов.
-     *
+     * Возвращает раздельные ошибки по определению устройств.
      * @param force Принудительно запрашивает повторное определение устройств, даже если список уже известен.
      * @group Устройства
      * @example
      * ```ts
-     * const { video, audio } = await client.detectDevices();
+     * const { video, audio, availability } = await client.detectDevices();
      * // video и audio — массивы MediaDeviceInfo
+     * // availability — статус доступности video и audio
      * const camera = video[0];
      * const mic = audio.find(d => d.label.includes('встроенный'));
      * ```
@@ -238,6 +239,12 @@ declare class Client {
      * @group Диагностика
      */
     getPreferRelay(): boolean;
+    /**
+     * Показывает, действует ли сейчас принудительный relay-режим,
+     * включённый SDK после неуспешного подключения receive-транспорта.
+     * @group Диагностика
+     */
+    isRelayEnforced(): boolean;
     /**
      * Меняет ICE transport policy для активных транспортов клиента.
      *

package/dist/constants/common.d.ts

@@ -55,3 +55,4 @@ export declare enum HttpStatusCode {
     GatewayTimeout = 504
 }
 export declare const CHANNEL_MESSAGES_DATA_PRODUCER = "channel-messages-data-producer";
+export declare const sdkVersion: string;

package/dist/constants/common.ts

@@ -83,3 +83,4 @@ export enum HttpStatusCode {
 }
 
 export const CHANNEL_MESSAGES_DATA_PRODUCER = 'channel-messages-data-producer';
+export const sdkVersion = String(process.env.SDK_VERSION);

package/dist/constants/events.d.ts

@@ -47,6 +47,7 @@ export declare const CLIENT_EVENTS: {
     readonly effectsEnabled: "effects-enabled";
     readonly effectsDisabled: "effects-disabled";
     readonly effectsFailed: "effects-failed";
+    readonly networkScoresUpdated: "network-scores-updated";
 };
 export declare const TRACK_EVENTS: {
     readonly volumeChanged: "volume-changed";

package/dist/constants/events.ts

@@ -48,6 +48,7 @@ export const CLIENT_EVENTS = {
   effectsEnabled: 'effects-enabled',
   effectsDisabled: 'effects-disabled',
   effectsFailed: 'effects-failed',
+  networkScoresUpdated: 'network-scores-updated',
 } as const;
 
 export const TRACK_EVENTS = {

package/dist/engine/Logger.d.ts

@@ -5,6 +5,7 @@ export interface RecordMeta {
     error?: unknown;
     clientTimestamp: string;
     from_sdk: boolean;
+    sdkVersion: string;
     case?: string;
     channelId?: string;
     applicationId?: string;

package/dist/engine/handlers/NetworkScoresUpdatedEventHandler.d.ts

@@ -0,0 +1,12 @@
+import type { NetworkScores } from 'webrtc-issue-detector';
+import type EnhancedEventEmitter from '../../EnhancedEventEmitter';
+import type ConfigService from '../../config/ConfigService';
+import type WIDHandler from '../WIDHandler';
+declare class NetworkScoresUpdatedEventHandler {
+    private readonly widHandler;
+    private readonly clientEventEmitter;
+    private readonly config;
+    constructor(widHandler: WIDHandler, clientEventEmitter: EnhancedEventEmitter, config: ConfigService);
+    handle(networkScores: NetworkScores): void;
+}
+export default NetworkScoresUpdatedEventHandler;

package/dist/engine/index.d.ts

@@ -84,6 +84,8 @@ declare class Engine {
     private triggerRejoinEventIfAppropriate;
     private watchNetworkState;
     private watchDocumentUnload;
+    private initTransports;
+    private registerNewTransports;
     private createSendRecvTransports;
 }
 export default Engine;

package/dist/engine/media/streamEffects/video/esdk/EffectsMetricsReporter.d.ts

@@ -0,0 +1,15 @@
+import type Logger from '../../../../Logger';
+import type { Metrics } from './tsvb';
+export interface EffectsMetricsReporterParams {
+    logger: Logger;
+    getMetrics: () => Metrics | undefined;
+    pollIntervalMs?: number;
+    minLogIntervalMs?: number;
+}
+export default class EffectsMetricsReporter {
+    #private;
+    constructor(params: EffectsMetricsReporterParams);
+    start(): void;
+    stop(): void;
+    tick(): void;
+}

package/dist/engine/network/IceRecoveryService.d.ts

@@ -0,0 +1,16 @@
+import type { LoggerFactory } from '../../types/container';
+import type SignalingApiClient from '../signalingApiClient/SignalingApiClient';
+import type { IceParameters } from 'mediasoup-client/lib/Transport';
+import type { LDTransport } from '../../types/mediasoup';
+import type TransportStateMonitor from './TransportStateMonitor';
+declare class IceRecoveryService {
+    private readonly signalingApiClient;
+    private readonly transportStateMonitor;
+    private readonly logger;
+    constructor(signalingApiClient: SignalingApiClient, loggerFactory: LoggerFactory, transportStateMonitor: TransportStateMonitor);
+    getIceParameters(transport: LDTransport): Promise<IceParameters>;
+    restartIce(transport: LDTransport): Promise<void>;
+    handleConnectionStateChange(transport: LDTransport, state: RTCPeerConnectionState): void;
+    cancelAll(): void;
+}
+export default IceRecoveryService;

package/dist/engine/network/NetworkTransportPolicyManager.d.ts

@@ -1,15 +1,18 @@
 import type { TransportDirection } from '../../types/network';
 import Network from './index';
 import { Logger } from '../../types/common';
+export type RelayEscalationHandler = () => Promise<void> | void;
 declare class NetworkTransportPolicyManager {
     #private;
     private readonly network;
     private readonly loggerFactory;
     constructor(network: Network, loggerFactory: (namespace: string) => Logger);
+    setRelayEscalationHandler(handler: RelayEscalationHandler): void;
     startMonitoring(): void;
     stopMonitoring(): void;
     changeIceTransportPolicy(policy: RTCIceTransportPolicy): Promise<void>;
     private readonly handleTransportState;
+    private triggerRelayEscalation;
     private recordDisconnectAndGetCount;
     private applyRelayPolicy;
     escalateDirectionToRelay(direction: TransportDirection): Promise<void>;

package/dist/engine/network/TransportStateMonitor.d.ts

@@ -0,0 +1,20 @@
+import type { LoggerFactory } from '../../types/container';
+import type { LDTransport } from '../../types/mediasoup';
+interface TransportStateMonitorScheduleOptions {
+    immediate?: boolean;
+    intervalMs?: number;
+}
+interface SchedulePayload {
+    transport: LDTransport;
+    options: TransportStateMonitorScheduleOptions;
+    restartIce: (transport: LDTransport) => Promise<void>;
+}
+declare class TransportStateMonitor {
+    private readonly logger;
+    private readonly handles;
+    constructor(loggerFactory: LoggerFactory);
+    schedule(payload: SchedulePayload): void;
+    cancel(transportId: string): void;
+    cancelAll(): void;
+}
+export default TransportStateMonitor;

package/dist/engine/network/constants.d.ts

@@ -0,0 +1 @@
+export declare const RESTART_ICE_INTERVAL_MS = 1500;

package/dist/engine/network/index.d.ts

@@ -1,5 +1,5 @@
 import { Device, type types } from 'mediasoup-client';
-import { IceParameters } from 'mediasoup-client/lib/Transport';
+import { ConnectionState } from 'mediasoup-client/lib/Transport';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import { CreateConsumerPayload, CreateConsumerResponse, PeerResponse, Role, TransportsStateInfo, UpdatePeerAppDataPayload } from '../../types/common';
 import { ClientObserverEvents } from '../../types/engine';
@@ -8,10 +8,11 @@ import { NetworkObserverEvents } from '../../types/network';
 import { CallState } from '../CallState';
 import Logger from '../Logger';
 import { MyPeer } from '../MyPeer';
-import SignalingApiClient from '../signalingApiClient/SignalingApiClient';
-import DatachannelHeartbeater from './DatachannelHeartbeater';
-import DataChannelsManager from './DataChannelsManager';
-import SignalingHeartbeater from './SignalingHeartbeater';
+import type IceRecoveryService from './IceRecoveryService';
+import type SignalingApiClient from '../signalingApiClient/SignalingApiClient';
+import type DatachannelHeartbeater from './DatachannelHeartbeater';
+import type DataChannelsManager from './DataChannelsManager';
+import type SignalingHeartbeater from './SignalingHeartbeater';
 declare class Network {
     #private;
     private readonly state;
@@ -21,13 +22,14 @@ declare class Network {
     private readonly signalingApiClient;
     private readonly datachannelHeartbeater;
     private readonly signalingHeartbeater;
+    private readonly iceRecoveryService;
     sendTransport?: LDTransport;
     receiveTransport?: LDTransport;
     heartbeatDataProducer?: types.DataProducer;
     signalingTransport?: LDTransport;
     private preferRelay?;
     peersLoaded: boolean;
-    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>, dataChannelsManager: DataChannelsManager, signalingApiClient: SignalingApiClient, datachannelHeartbeater: DatachannelHeartbeater, signalingHeartbeater: SignalingHeartbeater);
+    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>, dataChannelsManager: DataChannelsManager, signalingApiClient: SignalingApiClient, datachannelHeartbeater: DatachannelHeartbeater, signalingHeartbeater: SignalingHeartbeater, iceRecoveryService: IceRecoveryService);
     get isNetworkActive(): boolean;
     get observer(): EnhancedEventEmitter<NetworkObserverEvents>;
     private removeEventListeners;
@@ -40,7 +42,6 @@ declare class Network {
     createSendTransport(mediasoupDevice: Device): Promise<LDTransport>;
     createRecvTransport(mediasoupDevice: Device): Promise<LDTransport>;
     createSignalingTransport(mediasoupDevice: Device): Promise<LDTransport>;
-    getIceParameters(transport: LDTransport): Promise<IceParameters>;
     restartIce(transport: LDTransport): Promise<void>;
     createConsumer({ producerId, rtpCapabilities, producerPeerId, }: CreateConsumerPayload): Promise<CreateConsumerResponse>;
     initializeHeartbeats(): Promise<void>;
@@ -63,6 +64,8 @@ declare class Network {
     getTransportsStateInfo(): Promise<TransportsStateInfo>;
     setPreferRelay(value: boolean): void;
     getPreferRelay(): boolean;
+    isRelayEnforced(): boolean;
+    enforceRelay(durationMs: number): void;
     getChannelPeers(role?: Role): Promise<{
         peers: PeerResponse[];
     }>;
@@ -74,7 +77,7 @@ declare class Network {
     triggerChannelStateEvent(peersRole?: Role): Promise<number>;
     waitForChannelMessagesDataConsumerConnected(): Promise<void>;
     private waitForIceRestartStateTransition;
-    private waitForTransportTerminalState;
+    waitForTransportTerminalState(transport: LDTransport, timeoutAfter?: number): Promise<ConnectionState>;
     private waitForDataConsumerConnected;
     private getParsedTransportStats;
     private logTransportDetails;
@@ -85,5 +88,6 @@ declare class Network {
     private connectTransport;
     private subscribeCommonTransportEvents;
     private checkTransportState;
+    private isStaleTransport;
 }
 export default Network;

package/dist/engine/system/index.d.ts

@@ -1,4 +1,5 @@
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
+import { AvailableMediaDevices, MediaDeviceAvailability } from '../../types/common';
 import Logger from '../Logger';
 declare class System {
     #private;
@@ -8,18 +9,26 @@ declare class System {
     isDevicesDetected: boolean;
     availableVideoDevices: MediaDeviceInfo[];
     availableAudioDevices: MediaDeviceInfo[];
+    availableAudioOutputDevices: MediaDeviceInfo[];
+    audioDeviceAvailability?: MediaDeviceAvailability;
+    videoDeviceAvailability?: MediaDeviceAvailability;
+    audioOutputDeviceAvailability?: MediaDeviceAvailability;
     constructor(clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
     setIsEnableVideoDevicesLock(value: boolean): void;
     setIsEnableAudioDevicesLock(value: boolean): void;
     setAvailableVideoDevices(availableVideoDevices: MediaDeviceInfo[]): void;
     setAvailableAudioDevices(availableAudioDevices: MediaDeviceInfo[]): void;
+    setAvailableAudioOutputDevices(availableAudioOutputDevices: MediaDeviceInfo[]): void;
     requestMediaDevicesAccess(constraints?: MediaStreamConstraints): Promise<MediaStreamTrack[]>;
     hasAvailableMediaDevicesList(): Promise<boolean>;
     refreshAvailableMediaDevicesList(): Promise<MediaDeviceInfo[]>;
-    detectDevices(force?: boolean): Promise<void>;
+    detectDevices(force?: boolean): Promise<AvailableMediaDevices>;
     deviceChangeHandler(): Promise<void>;
+    private resetDeviceAvailability;
+    private getAvailableMediaDevices;
+    private getDeviceAvailability;
     listenDevices(): void;
-    private assertHasAccessToMediaDevices;
+    private requestMediaDeviceAccessAvailability;
     private tryToAccessDevices;
 }
 export default System;

package/dist/errors/ConstraintError.d.ts

@@ -0,0 +1,15 @@
+import OperationError from './OperationError';
+interface ConstraintErrorOptions {
+    errorCode: string;
+    actual?: string;
+}
+export declare const isOverconstrainedError: (error: unknown) => error is OverconstrainedError;
+export declare const getRequestedConstraintValue: (constraints: MediaStreamConstraints, kind: "audio" | "video", constraint: string) => string;
+export declare const getActualConstraintValue: (track: MediaStreamTrack, constraint: string) => string;
+declare class ConstraintError extends OperationError {
+    readonly constraint: string;
+    readonly requested: string;
+    readonly actual?: string;
+    constructor(error: OverconstrainedError, constraints: MediaStreamConstraints, { errorCode, actual }: ConstraintErrorOptions);
+}
+export default ConstraintError;

package/dist/errors/MediaDeviceAccessError.d.ts

@@ -0,0 +1,6 @@
+import type { DeviceErrors } from '../types/common';
+declare class MediaDeviceAccessError extends Error {
+    readonly code: DeviceErrors;
+    constructor(code: DeviceErrors);
+}
+export default MediaDeviceAccessError;

package/dist/helpers/asyncInterval.d.ts

@@ -0,0 +1,10 @@
+interface AsyncIntervalHandle {
+    stop: () => void;
+}
+interface CreateAsyncIntervalPayload {
+    callback: () => Promise<void>;
+    intervalMs: number;
+    immediate?: boolean;
+}
+export declare const createAsyncInterval: (payload: CreateAsyncIntervalPayload) => AsyncIntervalHandle;
+export {};

package/dist/index.d.ts

@@ -10,9 +10,10 @@ export type { Effects, LayoutTypes } from './engine/media/streamEffects/video/es
 export type { AudioStreamStats, MOSScores, VideoStreamStats, } from './qoe/types';
 export type { ClientParams } from './types/client';
 export { DeviceErrors, TrackLabel, } from './types/common';
-export type { ConsumerData, ActivityConfirmationRequiredPayload, AudioEncoderConfig, AvailableMediaDevices, BaseTrackInfo, ChannelEvent, CreateCameraVideoTrackOptions, CreateCustomAudioOptions, CreateCustomVideoOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, EncoderConfig, JoinChannelParams, PayloadOfPublishedMedia, PayloadOfUnpublishedMedia, ProducerData, PeerGroup, PeerInfo, PeerTrackInfo, Role, SubscribeOptions, TransformParams, TrackTransformParams, TrackForceClosedPayload, TrackInboundStats, TrackLabelString, TrackOutboundStats, TransportsStateInfo, VideoEncoderConfig, VideoCodec, PreferredLayersParams, SpatialLayerParams, } from './types/common';
+export type { ConsumerData, ActivityConfirmationRequiredPayload, AudioEncoderConfig, AvailableMediaDevices, BaseTrackInfo, MediaDeviceAvailability, MediaDeviceAvailabilityReason, ChannelEvent, CreateCameraVideoTrackOptions, CreateCustomAudioOptions, CreateCustomVideoOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, EncoderConfig, InputKind, JoinChannelParams, PayloadOfPublishedMedia, PayloadOfUnpublishedMedia, ProducerData, PeerGroup, PeerInfo, PeerTrackInfo, Role, SubscribeOptions, TransformParams, TrackTransformParams, TrackForceClosedPayload, TrackInboundStats, TrackLabelString, TrackOutboundStats, TransportsStateInfo, VideoEncoderConfig, VideoCodec, PreferredLayersParams, SpatialLayerParams, } from './types/common';
 export type { ChannelStateInconsistentPayload, ClientObserverEvents, IssuesHandler, NetworkScoresUpdatedHandler, ProducePermissionsChangedPayload, } from './types/engine';
 export type { AudioTrack, BaseTrack, InitEffectsSDKParams, Track, VideoTrack, VideoTrackPublishParams, } from './types/media';
 export type { IceTransportPolicy } from './types/network';
 export type { PeerConsumer } from './types/peerConsumer';
 export type { PeerTrack, PeerTrackObserverEvents } from './types/peerTrack';
+export type { NetworkScores } from 'webrtc-issue-detector';